From 7843261ba1276557c10ef80e5feca69049ab0218 Mon Sep 17 00:00:00 2001 From: Thiago Jung Bauermann Date: Thu, 16 Oct 2008 14:46:20 +0000 Subject: [PATCH] Add gdb/python/python-value.c, which I forgot to do in my previous commit. --- gdb/python/python-value.c | 689 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 689 insertions(+) create mode 100644 gdb/python/python-value.c diff --git a/gdb/python/python-value.c b/gdb/python/python-value.c new file mode 100644 index 0000000000..f53219f907 --- /dev/null +++ b/gdb/python/python-value.c @@ -0,0 +1,689 @@ +/* Python interface to values. + + Copyright (C) 2008 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "defs.h" +#include "charset.h" +#include "value.h" +#include "exceptions.h" +#include "language.h" +#include "dfp.h" + +/* List of all values which are currently exposed to Python. It is + maintained so that when an objfile is discarded, preserve_values + can copy the values' types if needed. This is declared + unconditionally to reduce the number of uses of HAVE_PYTHON in the + generic code. */ +struct value *values_in_python; + +#ifdef HAVE_PYTHON + +#include "python-internal.h" + +/* Even though Python scalar types directly map to host types, we use + target types here to remain consistent with the the values system in + GDB (which uses target arithmetic). */ + +/* Python's integer type corresponds to C's long type. */ +#define builtin_type_pyint builtin_type (current_gdbarch)->builtin_long + +/* Python's float type corresponds to C's double type. */ +#define builtin_type_pyfloat builtin_type (current_gdbarch)->builtin_double + +/* Python's long type corresponds to C's long long type. */ +#define builtin_type_pylong builtin_type (current_gdbarch)->builtin_long_long + +#define builtin_type_pybool \ + language_bool_type (current_language, current_gdbarch) + +typedef struct { + PyObject_HEAD + struct value *value; + int owned_by_gdb; +} value_object; + +static void valpy_dealloc (PyObject *obj); +static PyObject *valpy_new (PyTypeObject *subtype, PyObject *args, + PyObject *keywords); +static Py_ssize_t valpy_length (PyObject *self); +static PyObject *valpy_getitem (PyObject *self, PyObject *key); +static int valpy_setitem (PyObject *self, PyObject *key, PyObject *value); +static PyObject *valpy_str (PyObject *self); +static PyObject *valpy_add (PyObject *self, PyObject *other); +static PyObject *valpy_subtract (PyObject *self, PyObject *other); +static PyObject *valpy_multiply (PyObject *self, PyObject *other); +static PyObject *valpy_divide (PyObject *self, PyObject *other); +static PyObject *valpy_remainder (PyObject *self, PyObject *other); +static PyObject *valpy_power (PyObject *self, PyObject *other, PyObject *unused); +static PyObject *valpy_negative (PyObject *self); +static PyObject *valpy_positive (PyObject *self); +static PyObject *valpy_absolute (PyObject *self); +static int valpy_nonzero (PyObject *self); +static PyObject *valpy_richcompare (PyObject *self, PyObject *other, int op); +static PyObject *valpy_dereference (PyObject *self, PyObject *args); + +static PyMethodDef value_object_methods[] = { + { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." }, + {NULL} /* Sentinel */ +}; + +static PyNumberMethods value_object_as_number = { + valpy_add, + valpy_subtract, + valpy_multiply, + valpy_divide, + valpy_remainder, + NULL, /* nb_divmod */ + valpy_power, /* nb_power */ + valpy_negative, /* nb_negative */ + valpy_positive, /* nb_positive */ + valpy_absolute, /* nb_absolute */ + valpy_nonzero /* nb_nonzero */ +}; + +static PyMappingMethods value_object_as_mapping = { + valpy_length, + valpy_getitem, + valpy_setitem +}; + +PyTypeObject value_object_type = { + PyObject_HEAD_INIT (NULL) + 0, /*ob_size*/ + "gdb.Value", /*tp_name*/ + sizeof (value_object), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + valpy_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + &value_object_as_number, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + &value_object_as_mapping, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + valpy_str, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/ + "GDB value object", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + valpy_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + value_object_methods /* tp_methods */ +}; + + +/* Called by the Python interpreter when deallocating a value object. */ +static void +valpy_dealloc (PyObject *obj) +{ + value_object *self = (value_object *) obj; + + value_remove_from_list (&values_in_python, self->value); + + if (!self->owned_by_gdb) + value_free (self->value); + self->ob_type->tp_free (self); +} + +/* Called when a new gdb.Value object needs to be allocated. */ +static PyObject * +valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) +{ + struct value *value = NULL; /* Initialize to appease gcc warning. */ + value_object *value_obj; + volatile struct gdb_exception except; + + if (PyTuple_Size (args) != 1) + { + PyErr_SetString (PyExc_TypeError, _("Value object creation takes only " + "1 argument")); + return NULL; + } + + value_obj = (value_object *) subtype->tp_alloc (subtype, 1); + if (value_obj == NULL) + { + PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to " + "create Value object.")); + return NULL; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + value = convert_value_from_python (PyTuple_GetItem (args, 0)); + } + if (except.reason < 0) + { + subtype->tp_free (value_obj); + return PyErr_Format (except.reason == RETURN_QUIT + ? PyExc_KeyboardInterrupt : PyExc_TypeError, + "%s", except.message); + } + + value_obj->value = value; + release_value (value); + value_prepend_to_list (&values_in_python, value); + + return (PyObject *) value_obj; +} + +/* Given a value of a pointer type, apply the C unary * operator to it. */ +static PyObject * +valpy_dereference (PyObject *self, PyObject *args) +{ + struct value *res_val = NULL; /* Initialize to appease gcc warning. */ + volatile struct gdb_exception except; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + res_val = value_ind (((value_object *) self)->value); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return value_to_value_object (res_val); +} + +static Py_ssize_t +valpy_length (PyObject *self) +{ + /* We don't support getting the number of elements in a struct / class. */ + PyErr_SetString (PyExc_NotImplementedError, + "Invalid operation on gdb.Value."); + return -1; +} + +/* Given string name of an element inside structure, return its value + object. */ +static PyObject * +valpy_getitem (PyObject *self, PyObject *key) +{ + value_object *self_value = (value_object *) self; + char *field; + struct value *res_val = NULL; /* Initialize to appease gcc warning. */ + struct cleanup *old; + volatile struct gdb_exception except; + + field = python_string_to_target_string (key); + if (field == NULL) + return NULL; + + old = make_cleanup (xfree, field); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + res_val = value_struct_elt (&self_value->value, NULL, field, 0, NULL); + } + GDB_PY_HANDLE_EXCEPTION (except); + + do_cleanups (old); + + return value_to_value_object (res_val); +} + +static int +valpy_setitem (PyObject *self, PyObject *key, PyObject *value) +{ + PyErr_Format (PyExc_NotImplementedError, + _("Setting of struct elements is not currently supported.")); + return -1; +} + +/* Called by the Python interpreter to obtain string representation + of the object. */ +static PyObject * +valpy_str (PyObject *self) +{ + char *s = NULL; + long dummy; + struct ui_file *stb; + struct cleanup *old_chain; + PyObject *result; + volatile struct gdb_exception except; + + stb = mem_fileopen (); + old_chain = make_cleanup_ui_file_delete (stb); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + common_val_print (((value_object *) self)->value, stb, 0, 0, 0, + Val_pretty_default, current_language); + s = ui_file_xstrdup (stb, &dummy); + } + GDB_PY_HANDLE_EXCEPTION (except); + + do_cleanups (old_chain); + + result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL); + xfree (s); + + return result; +} + +enum valpy_opcode +{ + VALPY_ADD, + VALPY_SUB, + VALPY_MUL, + VALPY_DIV, + VALPY_REM, + VALPY_POW +}; + +/* If TYPE is a reference, return the target; otherwise return TYPE. */ +#define STRIP_REFERENCE(TYPE) \ + ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE)) + +/* Returns a value object which is the result of applying the operation + specified by OPCODE to the given arguments. */ +static PyObject * +valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) +{ + struct value *res_val = NULL; /* Initialize to appease gcc warning. */ + volatile struct gdb_exception except; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + struct value *arg1, *arg2; + + /* If the gdb.Value object is the second operand, then it will be passed + to us as the OTHER argument, and SELF will be an entirely different + kind of object, altogether. Because of this, we can't assume self is + a gdb.Value object and need to convert it from python as well. */ + arg1 = convert_value_from_python (self); + arg2 = convert_value_from_python (other); + + switch (opcode) + { + case VALPY_ADD: + { + struct type *ltype = value_type (arg1); + struct type *rtype = value_type (arg2); + + CHECK_TYPEDEF (ltype); + ltype = STRIP_REFERENCE (ltype); + CHECK_TYPEDEF (rtype); + rtype = STRIP_REFERENCE (rtype); + + if (TYPE_CODE (ltype) == TYPE_CODE_PTR) + res_val = value_ptradd (arg1, arg2); + else if (TYPE_CODE (rtype) == TYPE_CODE_PTR) + res_val = value_ptradd (arg2, arg1); + else + res_val = value_binop (arg1, arg2, BINOP_ADD); + } + break; + case VALPY_SUB: + { + struct type *ltype = value_type (arg1); + struct type *rtype = value_type (arg2); + + CHECK_TYPEDEF (ltype); + ltype = STRIP_REFERENCE (ltype); + CHECK_TYPEDEF (rtype); + rtype = STRIP_REFERENCE (rtype); + + if (TYPE_CODE (ltype) == TYPE_CODE_PTR) + { + if (TYPE_CODE (rtype) == TYPE_CODE_PTR) + /* A ptrdiff_t for the target would be preferable + here. */ + res_val = value_from_longest (builtin_type_pyint, + value_ptrdiff (arg1, arg2)); + else + res_val = value_ptrsub (arg1, arg2); + } + else + res_val = value_binop (arg1, arg2, BINOP_SUB); + } + break; + case VALPY_MUL: + res_val = value_binop (arg1, arg2, BINOP_MUL); + break; + case VALPY_DIV: + res_val = value_binop (arg1, arg2, BINOP_DIV); + break; + case VALPY_REM: + res_val = value_binop (arg1, arg2, BINOP_REM); + break; + case VALPY_POW: + res_val = value_binop (arg1, arg2, BINOP_EXP); + break; + } + } + GDB_PY_HANDLE_EXCEPTION (except); + + return value_to_value_object (res_val); +} + +static PyObject * +valpy_add (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_ADD, self, other); +} + +static PyObject * +valpy_subtract (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_SUB, self, other); +} + +static PyObject * +valpy_multiply (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_MUL, self, other); +} + +static PyObject * +valpy_divide (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_DIV, self, other); +} + +static PyObject * +valpy_remainder (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_REM, self, other); +} + +static PyObject * +valpy_power (PyObject *self, PyObject *other, PyObject *unused) +{ + /* We don't support the ternary form of pow. I don't know how to express + that, so let's just throw NotImplementedError to at least do something + about it. */ + if (unused != Py_None) + { + PyErr_SetString (PyExc_NotImplementedError, + "Invalid operation on gdb.Value."); + return NULL; + } + + return valpy_binop (VALPY_POW, self, other); +} + +static PyObject * +valpy_negative (PyObject *self) +{ + struct value *val = NULL; + volatile struct gdb_exception except; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + val = value_neg (((value_object *) self)->value); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return value_to_value_object (val); +} + +static PyObject * +valpy_positive (PyObject *self) +{ + struct value *copy = value_copy (((value_object *) self)->value); + + return value_to_value_object (copy); +} + +static PyObject * +valpy_absolute (PyObject *self) +{ + if (value_less (((value_object *) self)->value, + value_from_longest (builtin_type_int8, 0))) + return valpy_negative (self); + else + return valpy_positive (self); +} + +/* Implements boolean evaluation of gdb.Value. */ +static int +valpy_nonzero (PyObject *self) +{ + value_object *self_value = (value_object *) self; + struct type *type; + + type = check_typedef (value_type (self_value->value)); + + if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR) + return !!value_as_long (self_value->value); + else if (TYPE_CODE (type) == TYPE_CODE_FLT) + return value_as_double (self_value->value) != 0; + else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT) + return !decimal_is_zero (value_contents (self_value->value), + TYPE_LENGTH (type)); + else + { + PyErr_SetString (PyExc_TypeError, _("Attempted truth testing on invalid " + "gdb.Value type.")); + return 0; + } +} + +/* Implements comparison operations for value objects. */ +static PyObject * +valpy_richcompare (PyObject *self, PyObject *other, int op) +{ + int result = 0; + struct value *value_self, *value_other; + volatile struct gdb_exception except; + + if (PyObject_TypeCheck (other, &value_object_type)) + value_other = ((value_object *) other)->value; + else if (PyInt_Check (other)) + { + LONGEST l; + + l = PyInt_AsLong (other); + if (PyErr_Occurred ()) + return NULL; + + value_other = value_from_longest (builtin_type_pyint, l); + } + else if (PyFloat_Check (other)) + { + DOUBLEST d; + + d = PyFloat_AsDouble (other); + if (PyErr_Occurred ()) + return NULL; + + value_other = value_from_double (builtin_type_pyfloat, d); + } + else if (PyString_Check (other) || PyUnicode_Check (other)) + { + char *str; + + str = python_string_to_target_string (other); + value_other = value_from_string (str); + xfree (str); + } + else if (other == Py_None) + /* Comparing with None is special. From what I can tell, in Python + None is smaller than anything else. */ + switch (op) { + case Py_LT: + case Py_LE: + case Py_EQ: + Py_RETURN_FALSE; + case Py_NE: + case Py_GT: + case Py_GE: + Py_RETURN_TRUE; + default: + /* Can't happen. */ + PyErr_SetString (PyExc_NotImplementedError, + "Invalid operation on gdb.Value."); + return NULL; + } + else + { + PyErr_SetString (PyExc_NotImplementedError, + "Operation not supported on gdb.Value of this type."); + return NULL; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + switch (op) { + case Py_LT: + result = value_less (((value_object *) self)->value, value_other); + break; + case Py_LE: + result = value_less (((value_object *) self)->value, value_other) + || value_equal (((value_object *) self)->value, value_other); + break; + case Py_EQ: + result = value_equal (((value_object *) self)->value, value_other); + break; + case Py_NE: + result = !value_equal (((value_object *) self)->value, value_other); + break; + case Py_GT: + result = value_less (value_other, ((value_object *) self)->value); + break; + case Py_GE: + result = value_less (value_other, ((value_object *) self)->value) + || value_equal (((value_object *) self)->value, value_other); + break; + default: + /* Can't happen. */ + PyErr_SetString (PyExc_NotImplementedError, + "Invalid operation on gdb.Value."); + return NULL; + } + } + GDB_PY_HANDLE_EXCEPTION (except); + + if (result == 1) + Py_RETURN_TRUE; + + Py_RETURN_FALSE; +} + +/* Returns an object for a value which is released from the all_values chain, + so its lifetime is not bound to the execution of a command. */ +PyObject * +value_to_value_object (struct value *val) +{ + value_object *val_obj; + + val_obj = PyObject_New (value_object, &value_object_type); + if (val_obj != NULL) + { + val_obj->value = val; + release_value (val); + value_prepend_to_list (&values_in_python, val); + } + + return (PyObject *) val_obj; +} + +/* Try to convert a Python value to a gdb value. If the value cannot + be converted, throw a gdb exception. */ + +struct value * +convert_value_from_python (PyObject *obj) +{ + struct value *value = NULL; /* -Wall */ + PyObject *target_str, *unicode_str; + struct cleanup *old; + + if (! obj) + error (_("Internal error while converting Python value.")); + + if (PyBool_Check (obj)) + value = value_from_longest (builtin_type_pybool, obj == Py_True); + else if (PyInt_Check (obj)) + value = value_from_longest (builtin_type_pyint, PyInt_AsLong (obj)); + else if (PyLong_Check (obj)) + { + LONGEST l = PyLong_AsLongLong (obj); + if (! PyErr_Occurred ()) + value = value_from_longest (builtin_type_pylong, l); + } + else if (PyFloat_Check (obj)) + { + double d = PyFloat_AsDouble (obj); + if (! PyErr_Occurred ()) + value = value_from_double (builtin_type_pyfloat, d); + } + else if (PyString_Check (obj) || PyUnicode_Check (obj)) + { + char *s; + + s = python_string_to_target_string (obj); + if (s == NULL) + return NULL; + + old = make_cleanup (xfree, s); + value = value_from_string (s); + do_cleanups (old); + } + else if (PyObject_TypeCheck (obj, &value_object_type)) + value = ((value_object *) obj)->value; + else + error (_("Could not convert Python object: %s"), + PyString_AsString (PyObject_Str (obj))); + + if (PyErr_Occurred ()) + error (_("Error converting Python value.")); + + return value; +} + +/* Returns value object in the ARGth position in GDB's history. */ +PyObject * +gdbpy_get_value_from_history (PyObject *self, PyObject *args) +{ + int i; + struct value *res_val = NULL; /* Initialize to appease gcc warning. */ + volatile struct gdb_exception except; + + if (!PyArg_ParseTuple (args, "i", &i)) + return NULL; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + res_val = access_value_history (i); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return value_to_value_object (res_val); +} + +void +gdbpy_initialize_values (void) +{ + value_object_type.tp_new = valpy_new; + if (PyType_Ready (&value_object_type) < 0) + return; + + Py_INCREF (&value_object_type); + PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type); + + values_in_python = NULL; +} + +#endif /* HAVE_PYTHON */