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_lvalue_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.
404 If LENGTH is provided then the length parameter is set to LENGTH.
405 Otherwise if the value is an array of known length then the array's length
406 is used. Otherwise the length will be set to -1 (meaning first null of
409 Note: In order to not break any existing uses this allows creating
410 lazy strings from anything. PR 20769. E.g.,
411 gdb.parse_and_eval("my_int_variable").lazy_string().
412 "It's easier to relax restrictions than it is to impose them after the
413 fact." So we should be flagging any unintended uses as errors, but it's
414 perhaps too late for that. */
417 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
419 gdb_py_longest length
= -1;
420 struct value
*value
= ((value_object
*) self
)->value
;
421 const char *user_encoding
= NULL
;
422 static char *keywords
[] = { "encoding", "length", NULL
};
423 PyObject
*str_obj
= NULL
;
425 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
426 &user_encoding
, &length
))
431 PyErr_SetString (PyExc_ValueError
, _("Invalid length."));
437 scoped_value_mark free_values
;
438 struct type
*type
, *realtype
;
441 type
= value_type (value
);
442 realtype
= check_typedef (type
);
444 switch (TYPE_CODE (realtype
))
446 case TYPE_CODE_ARRAY
:
448 LONGEST array_length
= -1;
449 LONGEST low_bound
, high_bound
;
451 /* PR 20786: There's no way to specify an array of length zero.
452 Record a length of [0,-1] which is how Ada does it. Anything
453 we do is broken, but this one possible solution. */
454 if (get_array_bounds (realtype
, &low_bound
, &high_bound
))
455 array_length
= high_bound
- low_bound
+ 1;
457 length
= array_length
;
458 else if (array_length
== -1)
460 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
463 else if (length
!= array_length
)
465 /* We need to create a new array type with the
467 if (length
> array_length
)
468 error (_("Length is larger than array size."));
469 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
471 low_bound
+ length
- 1);
473 addr
= value_address (value
);
477 /* If a length is specified we defer creating an array of the
478 specified width until we need to. */
479 addr
= value_as_address (value
);
482 /* Should flag an error here. PR 20769. */
483 addr
= value_address (value
);
487 str_obj
= gdbpy_create_lazy_string_object (addr
, length
, user_encoding
,
490 CATCH (except
, RETURN_MASK_ALL
)
492 GDB_PY_HANDLE_EXCEPTION (except
);
499 /* Implementation of gdb.Value.string ([encoding] [, errors]
500 [, length]) -> string. Return Unicode string with value contents.
501 If ENCODING is not given, the string is assumed to be encoded in
502 the target's charset. If LENGTH is provided, only fetch string to
503 the length provided. */
506 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
510 struct value
*value
= ((value_object
*) self
)->value
;
512 const char *encoding
= NULL
;
513 const char *errors
= NULL
;
514 const char *user_encoding
= NULL
;
515 const char *la_encoding
= NULL
;
516 struct type
*char_type
;
517 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
519 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
520 &user_encoding
, &errors
, &length
))
525 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
527 CATCH (except
, RETURN_MASK_ALL
)
529 GDB_PY_HANDLE_EXCEPTION (except
);
533 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
534 unicode
= PyUnicode_Decode ((const char *) buffer
,
535 length
* TYPE_LENGTH (char_type
),
542 /* A helper function that implements the various cast operators. */
545 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
547 PyObject
*type_obj
, *result
= NULL
;
550 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
553 type
= type_object_to_type (type_obj
);
556 PyErr_SetString (PyExc_RuntimeError
,
557 _("Argument must be a type."));
563 struct value
*val
= ((value_object
*) self
)->value
;
564 struct value
*res_val
;
565 scoped_value_mark free_values
;
567 if (op
== UNOP_DYNAMIC_CAST
)
568 res_val
= value_dynamic_cast (type
, val
);
569 else if (op
== UNOP_REINTERPRET_CAST
)
570 res_val
= value_reinterpret_cast (type
, val
);
573 gdb_assert (op
== UNOP_CAST
);
574 res_val
= value_cast (type
, val
);
577 result
= value_to_value_object (res_val
);
579 CATCH (except
, RETURN_MASK_ALL
)
581 GDB_PY_HANDLE_EXCEPTION (except
);
588 /* Implementation of the "cast" method. */
591 valpy_cast (PyObject
*self
, PyObject
*args
)
593 return valpy_do_cast (self
, args
, UNOP_CAST
);
596 /* Implementation of the "dynamic_cast" method. */
599 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
601 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
604 /* Implementation of the "reinterpret_cast" method. */
607 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
609 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
613 valpy_length (PyObject
*self
)
615 /* We don't support getting the number of elements in a struct / class. */
616 PyErr_SetString (PyExc_NotImplementedError
,
617 _("Invalid operation on gdb.Value."));
621 /* Return 1 if the gdb.Field object FIELD is present in the value V.
622 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
625 value_has_field (struct value
*v
, PyObject
*field
)
627 struct type
*parent_type
, *val_type
;
628 enum type_code type_code
;
629 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
632 if (type_object
== NULL
)
635 parent_type
= type_object_to_type (type_object
.get ());
636 if (parent_type
== NULL
)
638 PyErr_SetString (PyExc_TypeError
,
639 _("'parent_type' attribute of gdb.Field object is not a"
640 "gdb.Type object."));
646 val_type
= value_type (v
);
647 val_type
= check_typedef (val_type
);
648 if (TYPE_CODE (val_type
) == TYPE_CODE_REF
649 || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
650 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
652 type_code
= TYPE_CODE (val_type
);
653 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
654 && types_equal (val_type
, parent_type
))
659 CATCH (except
, RETURN_MASK_ALL
)
661 GDB_PY_SET_HANDLE_EXCEPTION (except
);
668 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
669 Returns 1 if the flag value is true, 0 if it is false, and -1 if
670 a Python error occurs. */
673 get_field_flag (PyObject
*field
, const char *flag_name
)
675 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
677 if (flag_object
== NULL
)
680 return PyObject_IsTrue (flag_object
.get ());
683 /* Return the "type" attribute of a gdb.Field object.
684 Returns NULL on error, with a Python exception set. */
687 get_field_type (PyObject
*field
)
689 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
692 if (ftype_obj
== NULL
)
694 ftype
= type_object_to_type (ftype_obj
.get ());
696 PyErr_SetString (PyExc_TypeError
,
697 _("'type' attribute of gdb.Field object is not a "
698 "gdb.Type object."));
703 /* Given string name or a gdb.Field object corresponding to an element inside
704 a structure, return its value object. Returns NULL on error, with a python
708 valpy_getitem (PyObject
*self
, PyObject
*key
)
710 struct gdb_exception except
= exception_none
;
711 value_object
*self_value
= (value_object
*) self
;
712 gdb::unique_xmalloc_ptr
<char> field
;
713 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
715 PyObject
*result
= NULL
;
717 if (gdbpy_is_string (key
))
719 field
= python_string_to_host_string (key
);
723 else if (gdbpy_is_field (key
))
725 int is_base_class
, valid_field
;
727 valid_field
= value_has_field (self_value
->value
, key
);
730 else if (valid_field
== 0)
732 PyErr_SetString (PyExc_TypeError
,
733 _("Invalid lookup for a field not contained in "
739 is_base_class
= get_field_flag (key
, "is_base_class");
740 if (is_base_class
< 0)
742 else if (is_base_class
> 0)
744 base_class_type
= get_field_type (key
);
745 if (base_class_type
== NULL
)
750 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
752 if (name_obj
== NULL
)
755 if (name_obj
!= Py_None
)
757 field
= python_string_to_host_string (name_obj
.get ());
763 if (!PyObject_HasAttrString (key
, "bitpos"))
765 PyErr_SetString (PyExc_AttributeError
,
766 _("gdb.Field object has no name and no "
767 "'bitpos' attribute."));
771 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
772 if (bitpos_obj
== NULL
)
774 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
777 field_type
= get_field_type (key
);
778 if (field_type
== NULL
)
786 struct value
*tmp
= self_value
->value
;
787 struct value
*res_val
= NULL
;
788 scoped_value_mark free_values
;
791 res_val
= value_struct_elt (&tmp
, NULL
, field
.get (), NULL
,
792 "struct/class/union");
793 else if (bitpos
>= 0)
794 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
795 "struct/class/union");
796 else if (base_class_type
!= NULL
)
798 struct type
*val_type
;
800 val_type
= check_typedef (value_type (tmp
));
801 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
802 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
803 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
804 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
807 res_val
= value_cast (base_class_type
, tmp
);
811 /* Assume we are attempting an array access, and let the
812 value code throw an exception if the index has an invalid
814 struct value
*idx
= convert_value_from_python (key
);
818 /* Check the value's type is something that can be accessed via
822 tmp
= coerce_ref (tmp
);
823 type
= check_typedef (value_type (tmp
));
824 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
825 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
826 error (_("Cannot subscript requested type."));
828 res_val
= value_subscript (tmp
, value_as_long (idx
));
833 result
= value_to_value_object (res_val
);
835 CATCH (ex
, RETURN_MASK_ALL
)
841 GDB_PY_HANDLE_EXCEPTION (except
);
847 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
849 PyErr_Format (PyExc_NotImplementedError
,
850 _("Setting of struct elements is not currently supported."));
854 /* Called by the Python interpreter to perform an inferior function
855 call on the value. Returns NULL on error, with a python exception set. */
857 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
859 Py_ssize_t args_count
;
860 struct value
*function
= ((value_object
*) self
)->value
;
861 struct value
**vargs
= NULL
;
862 struct type
*ftype
= NULL
;
863 struct value
*mark
= value_mark ();
864 PyObject
*result
= NULL
;
868 ftype
= check_typedef (value_type (function
));
870 CATCH (except
, RETURN_MASK_ALL
)
872 GDB_PY_HANDLE_EXCEPTION (except
);
876 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
878 PyErr_SetString (PyExc_RuntimeError
,
879 _("Value is not callable (not TYPE_CODE_FUNC)."));
883 if (! PyTuple_Check (args
))
885 PyErr_SetString (PyExc_TypeError
,
886 _("Inferior arguments must be provided in a tuple."));
890 args_count
= PyTuple_Size (args
);
895 vargs
= XALLOCAVEC (struct value
*, args_count
);
896 for (i
= 0; i
< args_count
; i
++)
898 PyObject
*item
= PyTuple_GetItem (args
, i
);
903 vargs
[i
] = convert_value_from_python (item
);
904 if (vargs
[i
] == NULL
)
911 scoped_value_mark free_values
;
912 struct value
*return_value
;
914 return_value
= call_function_by_hand (function
, args_count
, vargs
);
915 result
= value_to_value_object (return_value
);
917 CATCH (except
, RETURN_MASK_ALL
)
919 GDB_PY_HANDLE_EXCEPTION (except
);
926 /* Called by the Python interpreter to obtain string representation
929 valpy_str (PyObject
*self
)
931 struct value_print_options opts
;
933 get_user_print_options (&opts
);
940 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
941 &opts
, python_language
);
943 CATCH (except
, RETURN_MASK_ALL
)
945 GDB_PY_HANDLE_EXCEPTION (except
);
949 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
952 /* Implements gdb.Value.is_optimized_out. */
954 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
956 struct value
*value
= ((value_object
*) self
)->value
;
961 opt
= value_optimized_out (value
);
963 CATCH (except
, RETURN_MASK_ALL
)
965 GDB_PY_HANDLE_EXCEPTION (except
);
975 /* Implements gdb.Value.is_lazy. */
977 valpy_get_is_lazy (PyObject
*self
, void *closure
)
979 struct value
*value
= ((value_object
*) self
)->value
;
984 opt
= value_lazy (value
);
986 CATCH (except
, RETURN_MASK_ALL
)
988 GDB_PY_HANDLE_EXCEPTION (except
);
998 /* Implements gdb.Value.fetch_lazy (). */
1000 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1002 struct value
*value
= ((value_object
*) self
)->value
;
1006 if (value_lazy (value
))
1007 value_fetch_lazy (value
);
1009 CATCH (except
, RETURN_MASK_ALL
)
1011 GDB_PY_HANDLE_EXCEPTION (except
);
1018 /* Calculate and return the address of the PyObject as the value of
1019 the builtin __hash__ call. */
1021 valpy_hash (PyObject
*self
)
1023 return (intptr_t) self
;
1041 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1042 #define STRIP_REFERENCE(TYPE) \
1043 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1045 /* Helper for valpy_binop. Returns a value object which is the result
1046 of applying the operation specified by OPCODE to the given
1047 arguments. Throws a GDB exception on error. */
1050 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1052 PyObject
*result
= NULL
;
1054 struct value
*arg1
, *arg2
;
1055 struct value
*res_val
= NULL
;
1056 enum exp_opcode op
= OP_NULL
;
1059 scoped_value_mark free_values
;
1061 /* If the gdb.Value object is the second operand, then it will be
1062 passed to us as the OTHER argument, and SELF will be an entirely
1063 different kind of object, altogether. Because of this, we can't
1064 assume self is a gdb.Value object and need to convert it from
1066 arg1
= convert_value_from_python (self
);
1070 arg2
= convert_value_from_python (other
);
1078 struct type
*ltype
= value_type (arg1
);
1079 struct type
*rtype
= value_type (arg2
);
1081 ltype
= check_typedef (ltype
);
1082 ltype
= STRIP_REFERENCE (ltype
);
1083 rtype
= check_typedef (rtype
);
1084 rtype
= STRIP_REFERENCE (rtype
);
1087 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1088 && is_integral_type (rtype
))
1089 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1090 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
1091 && is_integral_type (ltype
))
1092 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1102 struct type
*ltype
= value_type (arg1
);
1103 struct type
*rtype
= value_type (arg2
);
1105 ltype
= check_typedef (ltype
);
1106 ltype
= STRIP_REFERENCE (ltype
);
1107 rtype
= check_typedef (rtype
);
1108 rtype
= STRIP_REFERENCE (rtype
);
1111 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1112 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1113 /* A ptrdiff_t for the target would be preferable here. */
1114 res_val
= value_from_longest (builtin_type_pyint
,
1115 value_ptrdiff (arg1
, arg2
));
1116 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1117 && is_integral_type (rtype
))
1118 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1145 op
= BINOP_BITWISE_AND
;
1148 op
= BINOP_BITWISE_IOR
;
1151 op
= BINOP_BITWISE_XOR
;
1157 if (binop_user_defined_p (op
, arg1
, arg2
))
1158 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1160 res_val
= value_binop (arg1
, arg2
, op
);
1164 result
= value_to_value_object (res_val
);
1169 /* Returns a value object which is the result of applying the operation
1170 specified by OPCODE to the given arguments. Returns NULL on error, with
1171 a python exception set. */
1173 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1175 PyObject
*result
= NULL
;
1179 result
= valpy_binop_throw (opcode
, self
, other
);
1181 CATCH (except
, RETURN_MASK_ALL
)
1183 GDB_PY_HANDLE_EXCEPTION (except
);
1191 valpy_add (PyObject
*self
, PyObject
*other
)
1193 return valpy_binop (VALPY_ADD
, self
, other
);
1197 valpy_subtract (PyObject
*self
, PyObject
*other
)
1199 return valpy_binop (VALPY_SUB
, self
, other
);
1203 valpy_multiply (PyObject
*self
, PyObject
*other
)
1205 return valpy_binop (VALPY_MUL
, self
, other
);
1209 valpy_divide (PyObject
*self
, PyObject
*other
)
1211 return valpy_binop (VALPY_DIV
, self
, other
);
1215 valpy_remainder (PyObject
*self
, PyObject
*other
)
1217 return valpy_binop (VALPY_REM
, self
, other
);
1221 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1223 /* We don't support the ternary form of pow. I don't know how to express
1224 that, so let's just throw NotImplementedError to at least do something
1226 if (unused
!= Py_None
)
1228 PyErr_SetString (PyExc_NotImplementedError
,
1229 "Invalid operation on gdb.Value.");
1233 return valpy_binop (VALPY_POW
, self
, other
);
1237 valpy_negative (PyObject
*self
)
1239 PyObject
*result
= NULL
;
1243 /* Perhaps overkill, but consistency has some virtue. */
1244 scoped_value_mark free_values
;
1247 val
= value_neg (((value_object
*) self
)->value
);
1248 result
= value_to_value_object (val
);
1250 CATCH (except
, RETURN_MASK_ALL
)
1252 GDB_PY_HANDLE_EXCEPTION (except
);
1260 valpy_positive (PyObject
*self
)
1262 return value_to_value_object (((value_object
*) self
)->value
);
1266 valpy_absolute (PyObject
*self
)
1268 struct value
*value
= ((value_object
*) self
)->value
;
1273 scoped_value_mark free_values
;
1275 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1278 CATCH (except
, RETURN_MASK_ALL
)
1280 GDB_PY_HANDLE_EXCEPTION (except
);
1285 return valpy_positive (self
);
1287 return valpy_negative (self
);
1290 /* Implements boolean evaluation of gdb.Value. */
1292 valpy_nonzero (PyObject
*self
)
1294 struct gdb_exception except
= exception_none
;
1295 value_object
*self_value
= (value_object
*) self
;
1297 int nonzero
= 0; /* Appease GCC warning. */
1301 type
= check_typedef (value_type (self_value
->value
));
1303 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1304 nonzero
= !!value_as_long (self_value
->value
);
1305 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1306 nonzero
= value_as_double (self_value
->value
) != 0;
1307 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1308 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1310 gdbarch_byte_order (get_type_arch (type
)));
1312 /* All other values are True. */
1315 CATCH (ex
, RETURN_MASK_ALL
)
1321 /* This is not documented in the Python documentation, but if this
1322 function fails, return -1 as slot_nb_nonzero does (the default
1323 Python nonzero function). */
1324 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1329 /* Implements ~ for value objects. */
1331 valpy_invert (PyObject
*self
)
1333 struct value
*val
= NULL
;
1337 val
= value_complement (((value_object
*) self
)->value
);
1339 CATCH (except
, RETURN_MASK_ALL
)
1341 GDB_PY_HANDLE_EXCEPTION (except
);
1345 return value_to_value_object (val
);
1348 /* Implements left shift for value objects. */
1350 valpy_lsh (PyObject
*self
, PyObject
*other
)
1352 return valpy_binop (VALPY_LSH
, self
, other
);
1355 /* Implements right shift for value objects. */
1357 valpy_rsh (PyObject
*self
, PyObject
*other
)
1359 return valpy_binop (VALPY_RSH
, self
, other
);
1362 /* Implements bitwise and for value objects. */
1364 valpy_and (PyObject
*self
, PyObject
*other
)
1366 return valpy_binop (VALPY_BITAND
, self
, other
);
1369 /* Implements bitwise or for value objects. */
1371 valpy_or (PyObject
*self
, PyObject
*other
)
1373 return valpy_binop (VALPY_BITOR
, self
, other
);
1376 /* Implements bitwise xor for value objects. */
1378 valpy_xor (PyObject
*self
, PyObject
*other
)
1380 return valpy_binop (VALPY_BITXOR
, self
, other
);
1383 /* Helper for valpy_richcompare. Implements comparison operations for
1384 value objects. Returns true/false on success. Returns -1 with a
1385 Python exception set if a Python error is detected. Throws a GDB
1386 exception on other errors (memory error, etc.). */
1389 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1392 struct value
*value_other
;
1393 struct value
*value_self
;
1395 scoped_value_mark free_values
;
1397 value_other
= convert_value_from_python (other
);
1398 if (value_other
== NULL
)
1401 value_self
= ((value_object
*) self
)->value
;
1406 result
= value_less (value_self
, value_other
);
1409 result
= value_less (value_self
, value_other
)
1410 || value_equal (value_self
, value_other
);
1413 result
= value_equal (value_self
, value_other
);
1416 result
= !value_equal (value_self
, value_other
);
1419 result
= value_less (value_other
, value_self
);
1422 result
= (value_less (value_other
, value_self
)
1423 || value_equal (value_self
, value_other
));
1427 PyErr_SetString (PyExc_NotImplementedError
,
1428 _("Invalid operation on gdb.Value."));
1437 /* Implements comparison operations for value objects. Returns NULL on error,
1438 with a python exception set. */
1440 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1444 if (other
== Py_None
)
1445 /* Comparing with None is special. From what I can tell, in Python
1446 None is smaller than anything else. */
1458 PyErr_SetString (PyExc_NotImplementedError
,
1459 _("Invalid operation on gdb.Value."));
1465 result
= valpy_richcompare_throw (self
, other
, op
);
1467 CATCH (except
, RETURN_MASK_ALL
)
1469 GDB_PY_HANDLE_EXCEPTION (except
);
1473 /* In this case, the Python exception has already been set. */
1484 /* Implements conversion to int. */
1486 valpy_int (PyObject
*self
)
1488 struct value
*value
= ((value_object
*) self
)->value
;
1489 struct type
*type
= value_type (value
);
1494 if (!is_integral_type (type
))
1495 error (_("Cannot convert value to int."));
1497 l
= value_as_long (value
);
1499 CATCH (except
, RETURN_MASK_ALL
)
1501 GDB_PY_HANDLE_EXCEPTION (except
);
1505 return gdb_py_object_from_longest (l
);
1509 /* Implements conversion to long. */
1511 valpy_long (PyObject
*self
)
1513 struct value
*value
= ((value_object
*) self
)->value
;
1514 struct type
*type
= value_type (value
);
1519 type
= check_typedef (type
);
1521 if (!is_integral_type (type
)
1522 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1523 error (_("Cannot convert value to long."));
1525 l
= value_as_long (value
);
1527 CATCH (except
, RETURN_MASK_ALL
)
1529 GDB_PY_HANDLE_EXCEPTION (except
);
1533 if (TYPE_UNSIGNED (type
))
1534 return gdb_py_long_from_ulongest (l
);
1536 return gdb_py_long_from_longest (l
);
1539 /* Implements conversion to float. */
1541 valpy_float (PyObject
*self
)
1543 struct value
*value
= ((value_object
*) self
)->value
;
1544 struct type
*type
= value_type (value
);
1549 type
= check_typedef (type
);
1551 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1552 error (_("Cannot convert value to float."));
1554 d
= value_as_double (value
);
1556 CATCH (except
, RETURN_MASK_ALL
)
1558 GDB_PY_HANDLE_EXCEPTION (except
);
1562 return PyFloat_FromDouble (d
);
1565 /* Returns an object for a value which is released from the all_values chain,
1566 so its lifetime is not bound to the execution of a command. */
1568 value_to_value_object (struct value
*val
)
1570 value_object
*val_obj
;
1572 val_obj
= PyObject_New (value_object
, &value_object_type
);
1573 if (val_obj
!= NULL
)
1575 val_obj
->value
= val
;
1576 release_value_or_incref (val
);
1577 val_obj
->address
= NULL
;
1578 val_obj
->type
= NULL
;
1579 val_obj
->dynamic_type
= NULL
;
1580 note_value (val_obj
);
1583 return (PyObject
*) val_obj
;
1586 /* Returns a borrowed reference to the struct value corresponding to
1587 the given value object. */
1589 value_object_to_value (PyObject
*self
)
1593 if (! PyObject_TypeCheck (self
, &value_object_type
))
1595 real
= (value_object
*) self
;
1599 /* Try to convert a Python value to a gdb value. If the value cannot
1600 be converted, set a Python exception and return NULL. Returns a
1601 reference to a new value on the all_values chain. */
1604 convert_value_from_python (PyObject
*obj
)
1606 struct value
*value
= NULL
; /* -Wall */
1609 gdb_assert (obj
!= NULL
);
1613 if (PyBool_Check (obj
))
1615 cmp
= PyObject_IsTrue (obj
);
1617 value
= value_from_longest (builtin_type_pybool
, cmp
);
1619 /* Make a long logic check first. In Python 3.x, internally,
1620 all integers are represented as longs. In Python 2.x, there
1621 is still a differentiation internally between a PyInt and a
1622 PyLong. Explicitly do this long check conversion first. In
1623 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1624 to be done first to ensure we do not lose information in the
1625 conversion process. */
1626 else if (PyLong_Check (obj
))
1628 LONGEST l
= PyLong_AsLongLong (obj
);
1630 if (PyErr_Occurred ())
1632 /* If the error was an overflow, we can try converting to
1633 ULONGEST instead. */
1634 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1636 PyObject
*etype
, *evalue
, *etraceback
;
1638 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1639 gdbpy_ref
<> zero (PyInt_FromLong (0));
1641 /* Check whether obj is positive. */
1642 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1646 ul
= PyLong_AsUnsignedLongLong (obj
);
1647 if (! PyErr_Occurred ())
1648 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1651 /* There's nothing we can do. */
1652 PyErr_Restore (etype
, evalue
, etraceback
);
1656 value
= value_from_longest (builtin_type_pylong
, l
);
1658 #if PY_MAJOR_VERSION == 2
1659 else if (PyInt_Check (obj
))
1661 long l
= PyInt_AsLong (obj
);
1663 if (! PyErr_Occurred ())
1664 value
= value_from_longest (builtin_type_pyint
, l
);
1667 else if (PyFloat_Check (obj
))
1669 double d
= PyFloat_AsDouble (obj
);
1671 if (! PyErr_Occurred ())
1672 value
= value_from_double (builtin_type_pyfloat
, d
);
1674 else if (gdbpy_is_string (obj
))
1676 gdb::unique_xmalloc_ptr
<char> s
1677 = python_string_to_target_string (obj
);
1679 value
= value_cstring (s
.get (), strlen (s
.get ()),
1680 builtin_type_pychar
);
1682 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1683 value
= value_copy (((value_object
*) obj
)->value
);
1684 else if (gdbpy_is_lazy_string (obj
))
1688 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1689 value
= value_copy (((value_object
*) result
)->value
);
1693 PyErr_Format (PyExc_TypeError
,
1694 _("Could not convert Python object: %S."), obj
);
1696 PyErr_Format (PyExc_TypeError
,
1697 _("Could not convert Python object: %s."),
1698 PyString_AsString (PyObject_Str (obj
)));
1701 CATCH (except
, RETURN_MASK_ALL
)
1703 PyErr_Format (except
.reason
== RETURN_QUIT
1704 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1705 "%s", except
.message
);
1713 /* Returns value object in the ARGth position in GDB's history. */
1715 gdbpy_history (PyObject
*self
, PyObject
*args
)
1718 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1720 if (!PyArg_ParseTuple (args
, "i", &i
))
1725 res_val
= access_value_history (i
);
1727 CATCH (except
, RETURN_MASK_ALL
)
1729 GDB_PY_HANDLE_EXCEPTION (except
);
1733 return value_to_value_object (res_val
);
1736 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1739 gdbpy_is_value_object (PyObject
*obj
)
1741 return PyObject_TypeCheck (obj
, &value_object_type
);
1745 gdbpy_initialize_values (void)
1747 if (PyType_Ready (&value_object_type
) < 0)
1750 return gdb_pymodule_addobject (gdb_module
, "Value",
1751 (PyObject
*) &value_object_type
);
1756 static PyGetSetDef value_object_getset
[] = {
1757 { "address", valpy_get_address
, NULL
, "The address of the value.",
1759 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1760 "Boolean telling whether the value is optimized "
1761 "out (i.e., not available).",
1763 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1764 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1765 "Dynamic type of the value.", NULL
},
1766 { "is_lazy", valpy_get_is_lazy
, NULL
,
1767 "Boolean telling whether the value is lazy (not fetched yet\n\
1768 from the inferior). A lazy value is fetched when needed, or when\n\
1769 the \"fetch_lazy()\" method is called.", NULL
},
1770 {NULL
} /* Sentinel */
1773 static PyMethodDef value_object_methods
[] = {
1774 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1775 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1776 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1777 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1779 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1780 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1781 Cast the value to the supplied type, as if by the C++\n\
1782 reinterpret_cast operator."
1784 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1785 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1786 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1787 { "reference_value", valpy_reference_value
, METH_NOARGS
,
1788 "Return a value of type TYPE_CODE_REF referencing this value." },
1789 { "const_value", valpy_const_value
, METH_NOARGS
,
1790 "Return a 'const' qualied version of the same value." },
1791 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1792 METH_VARARGS
| METH_KEYWORDS
,
1793 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1794 Return a lazy string representation of the value." },
1795 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1796 "string ([encoding] [, errors] [, length]) -> string\n\
1797 Return Unicode string representation of the value." },
1798 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1799 "Fetches the value from the inferior, if it was lazy." },
1800 {NULL
} /* Sentinel */
1803 static PyNumberMethods value_object_as_number
= {
1811 NULL
, /* nb_divmod */
1812 valpy_power
, /* nb_power */
1813 valpy_negative
, /* nb_negative */
1814 valpy_positive
, /* nb_positive */
1815 valpy_absolute
, /* nb_absolute */
1816 valpy_nonzero
, /* nb_nonzero */
1817 valpy_invert
, /* nb_invert */
1818 valpy_lsh
, /* nb_lshift */
1819 valpy_rsh
, /* nb_rshift */
1820 valpy_and
, /* nb_and */
1821 valpy_xor
, /* nb_xor */
1822 valpy_or
, /* nb_or */
1824 valpy_long
, /* nb_int */
1825 NULL
, /* reserved */
1827 NULL
, /* nb_coerce */
1828 valpy_int
, /* nb_int */
1829 valpy_long
, /* nb_long */
1831 valpy_float
, /* nb_float */
1836 NULL
, /* nb_inplace_add */
1837 NULL
, /* nb_inplace_subtract */
1838 NULL
, /* nb_inplace_multiply */
1840 NULL
, /* nb_inplace_divide */
1842 NULL
, /* nb_inplace_remainder */
1843 NULL
, /* nb_inplace_power */
1844 NULL
, /* nb_inplace_lshift */
1845 NULL
, /* nb_inplace_rshift */
1846 NULL
, /* nb_inplace_and */
1847 NULL
, /* nb_inplace_xor */
1848 NULL
, /* nb_inplace_or */
1849 NULL
, /* nb_floor_divide */
1850 valpy_divide
, /* nb_true_divide */
1851 NULL
, /* nb_inplace_floor_divide */
1852 NULL
, /* nb_inplace_true_divide */
1853 #ifndef HAVE_LIBPYTHON2_4
1854 /* This was added in Python 2.5. */
1855 valpy_long
, /* nb_index */
1856 #endif /* HAVE_LIBPYTHON2_4 */
1859 static PyMappingMethods value_object_as_mapping
= {
1865 PyTypeObject value_object_type
= {
1866 PyVarObject_HEAD_INIT (NULL
, 0)
1867 "gdb.Value", /*tp_name*/
1868 sizeof (value_object
), /*tp_basicsize*/
1870 valpy_dealloc
, /*tp_dealloc*/
1876 &value_object_as_number
, /*tp_as_number*/
1877 0, /*tp_as_sequence*/
1878 &value_object_as_mapping
, /*tp_as_mapping*/
1879 valpy_hash
, /*tp_hash*/
1880 valpy_call
, /*tp_call*/
1881 valpy_str
, /*tp_str*/
1885 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1886 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1887 "GDB value object", /* tp_doc */
1888 0, /* tp_traverse */
1890 valpy_richcompare
, /* tp_richcompare */
1891 0, /* tp_weaklistoffset */
1893 0, /* tp_iternext */
1894 value_object_methods
, /* tp_methods */
1896 value_object_getset
, /* tp_getset */
1899 0, /* tp_descr_get */
1900 0, /* tp_descr_set */
1901 0, /* tp_dictoffset */
1904 valpy_new
/* tp_new */