1 /* Python interface to values.
3 Copyright (C) 2008-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_assert.h"
24 #include "exceptions.h"
29 #include "expression.h"
33 #include "python-internal.h"
35 /* Even though Python scalar types directly map to host types, we use
36 target types here to remain consistent with the values system in
37 GDB (which uses target arithmetic). */
39 /* Python's integer type corresponds to C's long type. */
40 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
42 /* Python's float type corresponds to C's double type. */
43 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
45 /* Python's long type corresponds to C's long long type. */
46 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
48 /* Python's long type corresponds to C's long long type. Unsigned version. */
49 #define builtin_type_upylong builtin_type \
50 (python_gdbarch)->builtin_unsigned_long_long
52 #define builtin_type_pybool \
53 language_bool_type (python_language, python_gdbarch)
55 #define builtin_type_pychar \
56 language_string_char_type (python_language, python_gdbarch)
58 typedef struct value_object
{
60 struct value_object
*next
;
61 struct value_object
*prev
;
65 PyObject
*dynamic_type
;
68 /* List of all values which are currently exposed to Python. It is
69 maintained so that when an objfile is discarded, preserve_values
70 can copy the values' types if needed. */
71 /* This variable is unnecessarily initialized to NULL in order to
72 work around a linker bug on MacOS. */
73 static value_object
*values_in_python
= NULL
;
75 /* Called by the Python interpreter when deallocating a value object. */
77 valpy_dealloc (PyObject
*obj
)
79 value_object
*self
= (value_object
*) obj
;
81 /* Remove SELF from the global list. */
83 self
->prev
->next
= self
->next
;
86 gdb_assert (values_in_python
== self
);
87 values_in_python
= self
->next
;
90 self
->next
->prev
= self
->prev
;
92 value_free (self
->value
);
95 /* Use braces to appease gcc warning. *sigh* */
97 Py_DECREF (self
->address
);
102 Py_DECREF (self
->type
);
105 Py_XDECREF (self
->dynamic_type
);
107 Py_TYPE (self
)->tp_free (self
);
110 /* Helper to push a Value object on the global list. */
112 note_value (value_object
*value_obj
)
114 value_obj
->next
= values_in_python
;
116 value_obj
->next
->prev
= value_obj
;
117 value_obj
->prev
= NULL
;
118 values_in_python
= value_obj
;
121 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
122 error, with a python exception set. */
124 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
126 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
127 value_object
*value_obj
;
129 if (PyTuple_Size (args
) != 1)
131 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
136 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
137 if (value_obj
== NULL
)
139 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
140 "create Value object."));
144 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
147 subtype
->tp_free (value_obj
);
151 value_obj
->value
= value
;
152 release_value_or_incref (value
);
153 value_obj
->address
= NULL
;
154 value_obj
->type
= NULL
;
155 value_obj
->dynamic_type
= NULL
;
156 note_value (value_obj
);
158 return (PyObject
*) value_obj
;
161 /* Iterate over all the Value objects, calling preserve_one_value on
164 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
165 struct objfile
*objfile
, htab_t copied_types
)
169 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
170 preserve_one_value (iter
->value
, objfile
, copied_types
);
173 /* Given a value of a pointer type, apply the C unary * operator to it. */
175 valpy_dereference (PyObject
*self
, PyObject
*args
)
177 volatile struct gdb_exception except
;
178 PyObject
*result
= NULL
;
180 TRY_CATCH (except
, RETURN_MASK_ALL
)
182 struct value
*res_val
;
183 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
185 res_val
= value_ind (((value_object
*) self
)->value
);
186 result
= value_to_value_object (res_val
);
187 do_cleanups (cleanup
);
189 GDB_PY_HANDLE_EXCEPTION (except
);
194 /* Given a value of a pointer type or a reference type, return the value
195 referenced. The difference between this function and valpy_dereference is
196 that the latter applies * unary operator to a value, which need not always
197 result in the value referenced. For example, for a value which is a reference
198 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
199 type 'int' while valpy_referenced_value will result in a value of type
203 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
205 volatile struct gdb_exception except
;
206 PyObject
*result
= NULL
;
208 TRY_CATCH (except
, RETURN_MASK_ALL
)
210 struct value
*self_val
, *res_val
;
211 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
213 self_val
= ((value_object
*) self
)->value
;
214 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
217 res_val
= value_ind (self_val
);
220 res_val
= coerce_ref (self_val
);
223 error(_("Trying to get the referenced value from a value which is "
224 "neither a pointer nor a reference."));
227 result
= value_to_value_object (res_val
);
228 do_cleanups (cleanup
);
230 GDB_PY_HANDLE_EXCEPTION (except
);
235 /* Return "&value". */
237 valpy_get_address (PyObject
*self
, void *closure
)
239 value_object
*val_obj
= (value_object
*) self
;
240 volatile struct gdb_exception except
;
242 if (!val_obj
->address
)
244 TRY_CATCH (except
, RETURN_MASK_ALL
)
246 struct value
*res_val
;
247 struct cleanup
*cleanup
248 = make_cleanup_value_free_to_mark (value_mark ());
250 res_val
= value_addr (val_obj
->value
);
251 val_obj
->address
= value_to_value_object (res_val
);
252 do_cleanups (cleanup
);
254 if (except
.reason
< 0)
256 val_obj
->address
= Py_None
;
261 Py_XINCREF (val_obj
->address
);
263 return val_obj
->address
;
266 /* Return type of the value. */
268 valpy_get_type (PyObject
*self
, void *closure
)
270 value_object
*obj
= (value_object
*) self
;
274 obj
->type
= type_to_type_object (value_type (obj
->value
));
278 Py_INCREF (obj
->type
);
282 /* Return dynamic type of the value. */
285 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
287 value_object
*obj
= (value_object
*) self
;
288 volatile struct gdb_exception except
;
289 struct type
*type
= NULL
;
291 if (obj
->dynamic_type
!= NULL
)
293 Py_INCREF (obj
->dynamic_type
);
294 return obj
->dynamic_type
;
297 TRY_CATCH (except
, RETURN_MASK_ALL
)
299 struct value
*val
= obj
->value
;
300 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
302 type
= value_type (val
);
303 CHECK_TYPEDEF (type
);
305 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
)
306 || (TYPE_CODE (type
) == TYPE_CODE_REF
))
307 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
309 struct value
*target
;
310 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
312 target
= value_ind (val
);
313 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
318 type
= lookup_pointer_type (type
);
320 type
= lookup_reference_type (type
);
323 else if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
324 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
327 /* Re-use object's static type. */
331 do_cleanups (cleanup
);
333 GDB_PY_HANDLE_EXCEPTION (except
);
336 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
338 obj
->dynamic_type
= type_to_type_object (type
);
340 Py_XINCREF (obj
->dynamic_type
);
341 return obj
->dynamic_type
;
344 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
345 string. Return a PyObject representing a lazy_string_object type.
346 A lazy string is a pointer to a string with an optional encoding and
347 length. If ENCODING is not given, encoding is set to None. If an
348 ENCODING is provided the encoding parameter is set to ENCODING, but
349 the string is not encoded. If LENGTH is provided then the length
350 parameter is set to LENGTH, otherwise length will be set to -1 (first
351 null of appropriate with). */
353 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
355 gdb_py_longest length
= -1;
356 struct value
*value
= ((value_object
*) self
)->value
;
357 const char *user_encoding
= NULL
;
358 static char *keywords
[] = { "encoding", "length", NULL
};
359 PyObject
*str_obj
= NULL
;
360 volatile struct gdb_exception except
;
362 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
363 &user_encoding
, &length
))
366 TRY_CATCH (except
, RETURN_MASK_ALL
)
368 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
370 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
371 value
= value_ind (value
);
373 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
377 do_cleanups (cleanup
);
379 GDB_PY_HANDLE_EXCEPTION (except
);
384 /* Implementation of gdb.Value.string ([encoding] [, errors]
385 [, length]) -> string. Return Unicode string with value contents.
386 If ENCODING is not given, the string is assumed to be encoded in
387 the target's charset. If LENGTH is provided, only fetch string to
388 the length provided. */
391 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
395 struct value
*value
= ((value_object
*) self
)->value
;
396 volatile struct gdb_exception except
;
398 const char *encoding
= NULL
;
399 const char *errors
= NULL
;
400 const char *user_encoding
= NULL
;
401 const char *la_encoding
= NULL
;
402 struct type
*char_type
;
403 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
405 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
406 &user_encoding
, &errors
, &length
))
409 TRY_CATCH (except
, RETURN_MASK_ALL
)
411 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
413 GDB_PY_HANDLE_EXCEPTION (except
);
415 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
416 unicode
= PyUnicode_Decode ((const char *) buffer
,
417 length
* TYPE_LENGTH (char_type
),
424 /* A helper function that implements the various cast operators. */
427 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
429 PyObject
*type_obj
, *result
= NULL
;
431 volatile struct gdb_exception except
;
433 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
436 type
= type_object_to_type (type_obj
);
439 PyErr_SetString (PyExc_RuntimeError
,
440 _("Argument must be a type."));
444 TRY_CATCH (except
, RETURN_MASK_ALL
)
446 struct value
*val
= ((value_object
*) self
)->value
;
447 struct value
*res_val
;
448 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
450 if (op
== UNOP_DYNAMIC_CAST
)
451 res_val
= value_dynamic_cast (type
, val
);
452 else if (op
== UNOP_REINTERPRET_CAST
)
453 res_val
= value_reinterpret_cast (type
, val
);
456 gdb_assert (op
== UNOP_CAST
);
457 res_val
= value_cast (type
, val
);
460 result
= value_to_value_object (res_val
);
461 do_cleanups (cleanup
);
463 GDB_PY_HANDLE_EXCEPTION (except
);
468 /* Implementation of the "cast" method. */
471 valpy_cast (PyObject
*self
, PyObject
*args
)
473 return valpy_do_cast (self
, args
, UNOP_CAST
);
476 /* Implementation of the "dynamic_cast" method. */
479 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
481 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
484 /* Implementation of the "reinterpret_cast" method. */
487 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
489 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
493 valpy_length (PyObject
*self
)
495 /* We don't support getting the number of elements in a struct / class. */
496 PyErr_SetString (PyExc_NotImplementedError
,
497 _("Invalid operation on gdb.Value."));
501 /* Return 1 if the gdb.Field object FIELD is present in the value V.
502 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
505 value_has_field (struct value
*v
, PyObject
*field
)
507 struct type
*parent_type
, *val_type
;
508 enum type_code type_code
;
509 PyObject
*type_object
= PyObject_GetAttrString (field
, "parent_type");
510 volatile struct gdb_exception except
;
513 if (type_object
== NULL
)
516 parent_type
= type_object_to_type (type_object
);
517 Py_DECREF (type_object
);
518 if (parent_type
== NULL
)
520 PyErr_SetString (PyExc_TypeError
,
521 _("'parent_type' attribute of gdb.Field object is not a"
522 "gdb.Type object."));
526 TRY_CATCH (except
, RETURN_MASK_ALL
)
528 val_type
= value_type (v
);
529 val_type
= check_typedef (val_type
);
530 if (TYPE_CODE (val_type
) == TYPE_CODE_REF
531 || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
532 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
534 type_code
= TYPE_CODE (val_type
);
535 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
536 && types_equal (val_type
, parent_type
))
541 GDB_PY_SET_HANDLE_EXCEPTION (except
);
546 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
547 Returns 1 if the flag value is true, 0 if it is false, and -1 if
548 a Python error occurs. */
551 get_field_flag (PyObject
*field
, const char *flag_name
)
554 PyObject
*flag_object
= PyObject_GetAttrString (field
, flag_name
);
556 if (flag_object
== NULL
)
559 flag_value
= PyObject_IsTrue (flag_object
);
560 Py_DECREF (flag_object
);
565 /* Return the "type" attribute of a gdb.Field object.
566 Returns NULL on error, with a Python exception set. */
569 get_field_type (PyObject
*field
)
571 PyObject
*ftype_obj
= PyObject_GetAttrString (field
, "type");
574 if (ftype_obj
== NULL
)
576 ftype
= type_object_to_type (ftype_obj
);
577 Py_DECREF (ftype_obj
);
579 PyErr_SetString (PyExc_TypeError
,
580 _("'type' attribute of gdb.Field object is not a "
581 "gdb.Type object."));
586 /* Given string name or a gdb.Field object corresponding to an element inside
587 a structure, return its value object. Returns NULL on error, with a python
591 valpy_getitem (PyObject
*self
, PyObject
*key
)
593 value_object
*self_value
= (value_object
*) self
;
595 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
597 volatile struct gdb_exception except
;
598 PyObject
*result
= NULL
;
600 if (gdbpy_is_string (key
))
602 field
= python_string_to_host_string (key
);
606 else if (gdbpy_is_field (key
))
608 int is_base_class
, valid_field
;
610 valid_field
= value_has_field (self_value
->value
, key
);
613 else if (valid_field
== 0)
615 PyErr_SetString (PyExc_TypeError
,
616 _("Invalid lookup for a field not contained in "
622 is_base_class
= get_field_flag (key
, "is_base_class");
623 if (is_base_class
< 0)
625 else if (is_base_class
> 0)
627 base_class_type
= get_field_type (key
);
628 if (base_class_type
== NULL
)
633 PyObject
*name_obj
= PyObject_GetAttrString (key
, "name");
635 if (name_obj
== NULL
)
638 if (name_obj
!= Py_None
)
640 field
= python_string_to_host_string (name_obj
);
641 Py_DECREF (name_obj
);
647 PyObject
*bitpos_obj
;
650 Py_DECREF (name_obj
);
652 if (!PyObject_HasAttrString (key
, "bitpos"))
654 PyErr_SetString (PyExc_AttributeError
,
655 _("gdb.Field object has no name and no "
656 "'bitpos' attribute."));
660 bitpos_obj
= PyObject_GetAttrString (key
, "bitpos");
661 if (bitpos_obj
== NULL
)
663 valid
= gdb_py_int_as_long (bitpos_obj
, &bitpos
);
664 Py_DECREF (bitpos_obj
);
668 field_type
= get_field_type (key
);
669 if (field_type
== NULL
)
675 TRY_CATCH (except
, RETURN_MASK_ALL
)
677 struct value
*tmp
= self_value
->value
;
678 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
679 struct value
*res_val
= NULL
;
682 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
683 else if (bitpos
>= 0)
684 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
685 "struct/class/union");
686 else if (base_class_type
!= NULL
)
688 struct type
*val_type
;
690 val_type
= check_typedef (value_type (tmp
));
691 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
692 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
693 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
694 res_val
= value_cast (lookup_reference_type (base_class_type
), tmp
);
696 res_val
= value_cast (base_class_type
, tmp
);
700 /* Assume we are attempting an array access, and let the
701 value code throw an exception if the index has an invalid
703 struct value
*idx
= convert_value_from_python (key
);
707 /* Check the value's type is something that can be accessed via
711 tmp
= coerce_ref (tmp
);
712 type
= check_typedef (value_type (tmp
));
713 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
714 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
715 error (_("Cannot subscript requested type."));
717 res_val
= value_subscript (tmp
, value_as_long (idx
));
722 result
= value_to_value_object (res_val
);
723 do_cleanups (cleanup
);
727 GDB_PY_HANDLE_EXCEPTION (except
);
733 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
735 PyErr_Format (PyExc_NotImplementedError
,
736 _("Setting of struct elements is not currently supported."));
740 /* Called by the Python interpreter to perform an inferior function
741 call on the value. Returns NULL on error, with a python exception set. */
743 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
745 Py_ssize_t args_count
;
746 volatile struct gdb_exception except
;
747 struct value
*function
= ((value_object
*) self
)->value
;
748 struct value
**vargs
= NULL
;
749 struct type
*ftype
= NULL
;
750 struct value
*mark
= value_mark ();
751 PyObject
*result
= NULL
;
753 TRY_CATCH (except
, RETURN_MASK_ALL
)
755 ftype
= check_typedef (value_type (function
));
757 GDB_PY_HANDLE_EXCEPTION (except
);
759 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
761 PyErr_SetString (PyExc_RuntimeError
,
762 _("Value is not callable (not TYPE_CODE_FUNC)."));
766 if (! PyTuple_Check (args
))
768 PyErr_SetString (PyExc_TypeError
,
769 _("Inferior arguments must be provided in a tuple."));
773 args_count
= PyTuple_Size (args
);
778 vargs
= alloca (sizeof (struct value
*) * args_count
);
779 for (i
= 0; i
< args_count
; i
++)
781 PyObject
*item
= PyTuple_GetItem (args
, i
);
786 vargs
[i
] = convert_value_from_python (item
);
787 if (vargs
[i
] == NULL
)
792 TRY_CATCH (except
, RETURN_MASK_ALL
)
794 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (mark
);
795 struct value
*return_value
;
797 return_value
= call_function_by_hand (function
, args_count
, vargs
);
798 result
= value_to_value_object (return_value
);
799 do_cleanups (cleanup
);
801 GDB_PY_HANDLE_EXCEPTION (except
);
806 /* Called by the Python interpreter to obtain string representation
809 valpy_str (PyObject
*self
)
813 struct value_print_options opts
;
814 volatile struct gdb_exception except
;
816 get_user_print_options (&opts
);
819 TRY_CATCH (except
, RETURN_MASK_ALL
)
821 struct ui_file
*stb
= mem_fileopen ();
822 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
824 common_val_print (((value_object
*) self
)->value
, stb
, 0,
825 &opts
, python_language
);
826 s
= ui_file_xstrdup (stb
, NULL
);
828 do_cleanups (old_chain
);
830 GDB_PY_HANDLE_EXCEPTION (except
);
832 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
838 /* Implements gdb.Value.is_optimized_out. */
840 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
842 struct value
*value
= ((value_object
*) self
)->value
;
844 volatile struct gdb_exception except
;
846 TRY_CATCH (except
, RETURN_MASK_ALL
)
848 opt
= value_optimized_out (value
);
850 GDB_PY_HANDLE_EXCEPTION (except
);
858 /* Implements gdb.Value.is_lazy. */
860 valpy_get_is_lazy (PyObject
*self
, void *closure
)
862 struct value
*value
= ((value_object
*) self
)->value
;
864 volatile struct gdb_exception except
;
866 TRY_CATCH (except
, RETURN_MASK_ALL
)
868 opt
= value_lazy (value
);
870 GDB_PY_HANDLE_EXCEPTION (except
);
878 /* Implements gdb.Value.fetch_lazy (). */
880 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
882 struct value
*value
= ((value_object
*) self
)->value
;
883 volatile struct gdb_exception except
;
885 TRY_CATCH (except
, RETURN_MASK_ALL
)
887 if (value_lazy (value
))
888 value_fetch_lazy (value
);
890 GDB_PY_HANDLE_EXCEPTION (except
);
895 /* Calculate and return the address of the PyObject as the value of
896 the builtin __hash__ call. */
898 valpy_hash (PyObject
*self
)
900 return (long) (intptr_t) self
;
918 /* If TYPE is a reference, return the target; otherwise return TYPE. */
919 #define STRIP_REFERENCE(TYPE) \
920 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
922 /* Returns a value object which is the result of applying the operation
923 specified by OPCODE to the given arguments. Returns NULL on error, with
924 a python exception set. */
926 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
928 volatile struct gdb_exception except
;
929 PyObject
*result
= NULL
;
931 TRY_CATCH (except
, RETURN_MASK_ALL
)
933 struct value
*arg1
, *arg2
;
934 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
935 struct value
*res_val
= NULL
;
937 /* If the gdb.Value object is the second operand, then it will be passed
938 to us as the OTHER argument, and SELF will be an entirely different
939 kind of object, altogether. Because of this, we can't assume self is
940 a gdb.Value object and need to convert it from python as well. */
941 arg1
= convert_value_from_python (self
);
944 do_cleanups (cleanup
);
948 arg2
= convert_value_from_python (other
);
951 do_cleanups (cleanup
);
959 struct type
*ltype
= value_type (arg1
);
960 struct type
*rtype
= value_type (arg2
);
962 CHECK_TYPEDEF (ltype
);
963 ltype
= STRIP_REFERENCE (ltype
);
964 CHECK_TYPEDEF (rtype
);
965 rtype
= STRIP_REFERENCE (rtype
);
967 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
968 && is_integral_type (rtype
))
969 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
970 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
971 && is_integral_type (ltype
))
972 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
974 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
979 struct type
*ltype
= value_type (arg1
);
980 struct type
*rtype
= value_type (arg2
);
982 CHECK_TYPEDEF (ltype
);
983 ltype
= STRIP_REFERENCE (ltype
);
984 CHECK_TYPEDEF (rtype
);
985 rtype
= STRIP_REFERENCE (rtype
);
987 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
988 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
989 /* A ptrdiff_t for the target would be preferable here. */
990 res_val
= value_from_longest (builtin_type_pyint
,
991 value_ptrdiff (arg1
, arg2
));
992 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
993 && is_integral_type (rtype
))
994 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
996 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
1000 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
1003 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
1006 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
1009 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
1012 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
1015 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
1018 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
1021 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
1024 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
1029 result
= value_to_value_object (res_val
);
1031 do_cleanups (cleanup
);
1033 GDB_PY_HANDLE_EXCEPTION (except
);
1039 valpy_add (PyObject
*self
, PyObject
*other
)
1041 return valpy_binop (VALPY_ADD
, self
, other
);
1045 valpy_subtract (PyObject
*self
, PyObject
*other
)
1047 return valpy_binop (VALPY_SUB
, self
, other
);
1051 valpy_multiply (PyObject
*self
, PyObject
*other
)
1053 return valpy_binop (VALPY_MUL
, self
, other
);
1057 valpy_divide (PyObject
*self
, PyObject
*other
)
1059 return valpy_binop (VALPY_DIV
, self
, other
);
1063 valpy_remainder (PyObject
*self
, PyObject
*other
)
1065 return valpy_binop (VALPY_REM
, self
, other
);
1069 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1071 /* We don't support the ternary form of pow. I don't know how to express
1072 that, so let's just throw NotImplementedError to at least do something
1074 if (unused
!= Py_None
)
1076 PyErr_SetString (PyExc_NotImplementedError
,
1077 "Invalid operation on gdb.Value.");
1081 return valpy_binop (VALPY_POW
, self
, other
);
1085 valpy_negative (PyObject
*self
)
1087 volatile struct gdb_exception except
;
1088 PyObject
*result
= NULL
;
1090 TRY_CATCH (except
, RETURN_MASK_ALL
)
1092 /* Perhaps overkill, but consistency has some virtue. */
1093 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1096 val
= value_neg (((value_object
*) self
)->value
);
1097 result
= value_to_value_object (val
);
1098 do_cleanups (cleanup
);
1100 GDB_PY_HANDLE_EXCEPTION (except
);
1106 valpy_positive (PyObject
*self
)
1108 return value_to_value_object (((value_object
*) self
)->value
);
1112 valpy_absolute (PyObject
*self
)
1114 struct value
*value
= ((value_object
*) self
)->value
;
1115 volatile struct gdb_exception except
;
1118 TRY_CATCH (except
, RETURN_MASK_ALL
)
1120 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1122 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1125 do_cleanups (cleanup
);
1127 GDB_PY_HANDLE_EXCEPTION (except
);
1130 return valpy_positive (self
);
1132 return valpy_negative (self
);
1135 /* Implements boolean evaluation of gdb.Value. */
1137 valpy_nonzero (PyObject
*self
)
1139 volatile struct gdb_exception except
;
1140 value_object
*self_value
= (value_object
*) self
;
1142 int nonzero
= 0; /* Appease GCC warning. */
1144 TRY_CATCH (except
, RETURN_MASK_ALL
)
1146 type
= check_typedef (value_type (self_value
->value
));
1148 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1149 nonzero
= !!value_as_long (self_value
->value
);
1150 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1151 nonzero
= value_as_double (self_value
->value
) != 0;
1152 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1153 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1155 gdbarch_byte_order (get_type_arch (type
)));
1157 /* All other values are True. */
1160 /* This is not documented in the Python documentation, but if this
1161 function fails, return -1 as slot_nb_nonzero does (the default
1162 Python nonzero function). */
1163 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1168 /* Implements ~ for value objects. */
1170 valpy_invert (PyObject
*self
)
1172 struct value
*val
= NULL
;
1173 volatile struct gdb_exception except
;
1175 TRY_CATCH (except
, RETURN_MASK_ALL
)
1177 val
= value_complement (((value_object
*) self
)->value
);
1179 GDB_PY_HANDLE_EXCEPTION (except
);
1181 return value_to_value_object (val
);
1184 /* Implements left shift for value objects. */
1186 valpy_lsh (PyObject
*self
, PyObject
*other
)
1188 return valpy_binop (VALPY_LSH
, self
, other
);
1191 /* Implements right shift for value objects. */
1193 valpy_rsh (PyObject
*self
, PyObject
*other
)
1195 return valpy_binop (VALPY_RSH
, self
, other
);
1198 /* Implements bitwise and for value objects. */
1200 valpy_and (PyObject
*self
, PyObject
*other
)
1202 return valpy_binop (VALPY_BITAND
, self
, other
);
1205 /* Implements bitwise or for value objects. */
1207 valpy_or (PyObject
*self
, PyObject
*other
)
1209 return valpy_binop (VALPY_BITOR
, self
, other
);
1212 /* Implements bitwise xor for value objects. */
1214 valpy_xor (PyObject
*self
, PyObject
*other
)
1216 return valpy_binop (VALPY_BITXOR
, self
, other
);
1219 /* Implements comparison operations for value objects. Returns NULL on error,
1220 with a python exception set. */
1222 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1225 volatile struct gdb_exception except
;
1227 if (other
== Py_None
)
1228 /* Comparing with None is special. From what I can tell, in Python
1229 None is smaller than anything else. */
1241 PyErr_SetString (PyExc_NotImplementedError
,
1242 _("Invalid operation on gdb.Value."));
1246 TRY_CATCH (except
, RETURN_MASK_ALL
)
1248 struct value
*value_other
, *mark
= value_mark ();
1249 struct cleanup
*cleanup
;
1251 value_other
= convert_value_from_python (other
);
1252 if (value_other
== NULL
)
1258 cleanup
= make_cleanup_value_free_to_mark (mark
);
1262 result
= value_less (((value_object
*) self
)->value
, value_other
);
1265 result
= value_less (((value_object
*) self
)->value
, value_other
)
1266 || value_equal (((value_object
*) self
)->value
, value_other
);
1269 result
= value_equal (((value_object
*) self
)->value
, value_other
);
1272 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
1275 result
= value_less (value_other
, ((value_object
*) self
)->value
);
1278 result
= value_less (value_other
, ((value_object
*) self
)->value
)
1279 || value_equal (((value_object
*) self
)->value
, value_other
);
1283 PyErr_SetString (PyExc_NotImplementedError
,
1284 _("Invalid operation on gdb.Value."));
1289 do_cleanups (cleanup
);
1291 GDB_PY_HANDLE_EXCEPTION (except
);
1293 /* In this case, the Python exception has already been set. */
1304 /* Implements conversion to int. */
1306 valpy_int (PyObject
*self
)
1308 struct value
*value
= ((value_object
*) self
)->value
;
1309 struct type
*type
= value_type (value
);
1311 volatile struct gdb_exception except
;
1313 TRY_CATCH (except
, RETURN_MASK_ALL
)
1315 if (!is_integral_type (type
))
1316 error (_("Cannot convert value to int."));
1318 l
= value_as_long (value
);
1320 GDB_PY_HANDLE_EXCEPTION (except
);
1322 return gdb_py_object_from_longest (l
);
1326 /* Implements conversion to long. */
1328 valpy_long (PyObject
*self
)
1330 struct value
*value
= ((value_object
*) self
)->value
;
1331 struct type
*type
= value_type (value
);
1333 volatile struct gdb_exception except
;
1335 TRY_CATCH (except
, RETURN_MASK_ALL
)
1337 CHECK_TYPEDEF (type
);
1339 if (!is_integral_type (type
)
1340 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1341 error (_("Cannot convert value to long."));
1343 l
= value_as_long (value
);
1345 GDB_PY_HANDLE_EXCEPTION (except
);
1347 return gdb_py_long_from_longest (l
);
1350 /* Implements conversion to float. */
1352 valpy_float (PyObject
*self
)
1354 struct value
*value
= ((value_object
*) self
)->value
;
1355 struct type
*type
= value_type (value
);
1357 volatile struct gdb_exception except
;
1359 TRY_CATCH (except
, RETURN_MASK_ALL
)
1361 CHECK_TYPEDEF (type
);
1363 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1364 error (_("Cannot convert value to float."));
1366 d
= value_as_double (value
);
1368 GDB_PY_HANDLE_EXCEPTION (except
);
1370 return PyFloat_FromDouble (d
);
1373 /* Returns an object for a value which is released from the all_values chain,
1374 so its lifetime is not bound to the execution of a command. */
1376 value_to_value_object (struct value
*val
)
1378 value_object
*val_obj
;
1380 val_obj
= PyObject_New (value_object
, &value_object_type
);
1381 if (val_obj
!= NULL
)
1383 val_obj
->value
= val
;
1384 release_value_or_incref (val
);
1385 val_obj
->address
= NULL
;
1386 val_obj
->type
= NULL
;
1387 val_obj
->dynamic_type
= NULL
;
1388 note_value (val_obj
);
1391 return (PyObject
*) val_obj
;
1394 /* Returns a borrowed reference to the struct value corresponding to
1395 the given value object. */
1397 value_object_to_value (PyObject
*self
)
1401 if (! PyObject_TypeCheck (self
, &value_object_type
))
1403 real
= (value_object
*) self
;
1407 /* Try to convert a Python value to a gdb value. If the value cannot
1408 be converted, set a Python exception and return NULL. Returns a
1409 reference to a new value on the all_values chain. */
1412 convert_value_from_python (PyObject
*obj
)
1414 struct value
*value
= NULL
; /* -Wall */
1415 volatile struct gdb_exception except
;
1418 gdb_assert (obj
!= NULL
);
1420 TRY_CATCH (except
, RETURN_MASK_ALL
)
1422 if (PyBool_Check (obj
))
1424 cmp
= PyObject_IsTrue (obj
);
1426 value
= value_from_longest (builtin_type_pybool
, cmp
);
1428 /* Make a long logic check first. In Python 3.x, internally,
1429 all integers are represented as longs. In Python 2.x, there
1430 is still a differentiation internally between a PyInt and a
1431 PyLong. Explicitly do this long check conversion first. In
1432 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1433 to be done first to ensure we do not lose information in the
1434 conversion process. */
1435 else if (PyLong_Check (obj
))
1437 LONGEST l
= PyLong_AsLongLong (obj
);
1439 if (PyErr_Occurred ())
1441 /* If the error was an overflow, we can try converting to
1442 ULONGEST instead. */
1443 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1445 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1447 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1448 zero
= PyInt_FromLong (0);
1450 /* Check whether obj is positive. */
1451 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1455 ul
= PyLong_AsUnsignedLongLong (obj
);
1456 if (! PyErr_Occurred ())
1457 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1460 /* There's nothing we can do. */
1461 PyErr_Restore (etype
, evalue
, etraceback
);
1467 value
= value_from_longest (builtin_type_pylong
, l
);
1469 else if (PyInt_Check (obj
))
1471 long l
= PyInt_AsLong (obj
);
1473 if (! PyErr_Occurred ())
1474 value
= value_from_longest (builtin_type_pyint
, l
);
1476 else if (PyFloat_Check (obj
))
1478 double d
= PyFloat_AsDouble (obj
);
1480 if (! PyErr_Occurred ())
1481 value
= value_from_double (builtin_type_pyfloat
, d
);
1483 else if (gdbpy_is_string (obj
))
1487 s
= python_string_to_target_string (obj
);
1490 struct cleanup
*old
;
1492 old
= make_cleanup (xfree
, s
);
1493 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1497 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1498 value
= value_copy (((value_object
*) obj
)->value
);
1499 else if (gdbpy_is_lazy_string (obj
))
1503 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1504 value
= value_copy (((value_object
*) result
)->value
);
1508 PyErr_Format (PyExc_TypeError
,
1509 _("Could not convert Python object: %S."), obj
);
1511 PyErr_Format (PyExc_TypeError
,
1512 _("Could not convert Python object: %s."),
1513 PyString_AsString (PyObject_Str (obj
)));
1516 if (except
.reason
< 0)
1518 PyErr_Format (except
.reason
== RETURN_QUIT
1519 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1520 "%s", except
.message
);
1527 /* Returns value object in the ARGth position in GDB's history. */
1529 gdbpy_history (PyObject
*self
, PyObject
*args
)
1532 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1533 volatile struct gdb_exception except
;
1535 if (!PyArg_ParseTuple (args
, "i", &i
))
1538 TRY_CATCH (except
, RETURN_MASK_ALL
)
1540 res_val
= access_value_history (i
);
1542 GDB_PY_HANDLE_EXCEPTION (except
);
1544 return value_to_value_object (res_val
);
1547 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1550 gdbpy_is_value_object (PyObject
*obj
)
1552 return PyObject_TypeCheck (obj
, &value_object_type
);
1556 gdbpy_initialize_values (void)
1558 if (PyType_Ready (&value_object_type
) < 0)
1561 return gdb_pymodule_addobject (gdb_module
, "Value",
1562 (PyObject
*) &value_object_type
);
1567 static PyGetSetDef value_object_getset
[] = {
1568 { "address", valpy_get_address
, NULL
, "The address of the value.",
1570 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1571 "Boolean telling whether the value is optimized "
1572 "out (i.e., not available).",
1574 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1575 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1576 "Dynamic type of the value.", NULL
},
1577 { "is_lazy", valpy_get_is_lazy
, NULL
,
1578 "Boolean telling whether the value is lazy (not fetched yet\n\
1579 from the inferior). A lazy value is fetched when needed, or when\n\
1580 the \"fetch_lazy()\" method is called.", NULL
},
1581 {NULL
} /* Sentinel */
1584 static PyMethodDef value_object_methods
[] = {
1585 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1586 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1587 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1588 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1590 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1591 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1592 Cast the value to the supplied type, as if by the C++\n\
1593 reinterpret_cast operator."
1595 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1596 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1597 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1598 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1599 METH_VARARGS
| METH_KEYWORDS
,
1600 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1601 Return a lazy string representation of the value." },
1602 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1603 "string ([encoding] [, errors] [, length]) -> string\n\
1604 Return Unicode string representation of the value." },
1605 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1606 "Fetches the value from the inferior, if it was lazy." },
1607 {NULL
} /* Sentinel */
1610 static PyNumberMethods value_object_as_number
= {
1618 NULL
, /* nb_divmod */
1619 valpy_power
, /* nb_power */
1620 valpy_negative
, /* nb_negative */
1621 valpy_positive
, /* nb_positive */
1622 valpy_absolute
, /* nb_absolute */
1623 valpy_nonzero
, /* nb_nonzero */
1624 valpy_invert
, /* nb_invert */
1625 valpy_lsh
, /* nb_lshift */
1626 valpy_rsh
, /* nb_rshift */
1627 valpy_and
, /* nb_and */
1628 valpy_xor
, /* nb_xor */
1629 valpy_or
, /* nb_or */
1631 valpy_long
, /* nb_int */
1632 NULL
, /* reserved */
1634 NULL
, /* nb_coerce */
1635 valpy_int
, /* nb_int */
1636 valpy_long
, /* nb_long */
1638 valpy_float
, /* nb_float */
1643 NULL
, /* nb_inplace_add */
1644 NULL
, /* nb_inplace_subtract */
1645 NULL
, /* nb_inplace_multiply */
1646 NULL
, /* nb_inplace_remainder */
1647 NULL
, /* nb_inplace_power */
1648 NULL
, /* nb_inplace_lshift */
1649 NULL
, /* nb_inplace_rshift */
1650 NULL
, /* nb_inplace_and */
1651 NULL
, /* nb_inplace_xor */
1652 NULL
, /* nb_inplace_or */
1653 NULL
, /* nb_floor_divide */
1654 valpy_divide
/* nb_true_divide */
1657 static PyMappingMethods value_object_as_mapping
= {
1663 PyTypeObject value_object_type
= {
1664 PyVarObject_HEAD_INIT (NULL
, 0)
1665 "gdb.Value", /*tp_name*/
1666 sizeof (value_object
), /*tp_basicsize*/
1668 valpy_dealloc
, /*tp_dealloc*/
1674 &value_object_as_number
, /*tp_as_number*/
1675 0, /*tp_as_sequence*/
1676 &value_object_as_mapping
, /*tp_as_mapping*/
1677 valpy_hash
, /*tp_hash*/
1678 valpy_call
, /*tp_call*/
1679 valpy_str
, /*tp_str*/
1683 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1684 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1685 "GDB value object", /* tp_doc */
1686 0, /* tp_traverse */
1688 valpy_richcompare
, /* tp_richcompare */
1689 0, /* tp_weaklistoffset */
1691 0, /* tp_iternext */
1692 value_object_methods
, /* tp_methods */
1694 value_object_getset
, /* tp_getset */
1697 0, /* tp_descr_get */
1698 0, /* tp_descr_set */
1699 0, /* tp_dictoffset */
1702 valpy_new
/* tp_new */