/* Python interface to values.
- Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2008-2015 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_assert.h"
#include "charset.h"
#include "value.h"
-#include "exceptions.h"
#include "language.h"
#include "dfp.h"
#include "valprint.h"
#include "infcall.h"
#include "expression.h"
#include "cp-abi.h"
-
-#ifdef HAVE_PYTHON
+#include "python.h"
#include "python-internal.h"
Py_XDECREF (self->dynamic_type);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
/* Helper to push a Value object on the global list. */
}
value_obj->value = value;
- value_incref (value);
+ release_value_or_incref (value);
value_obj->address = NULL;
value_obj->type = NULL;
value_obj->dynamic_type = NULL;
/* Iterate over all the Value objects, calling preserve_one_value on
each. */
void
-preserve_python_values (struct objfile *objfile, htab_t copied_types)
+gdbpy_preserve_values (const struct extension_language_defn *extlang,
+ struct objfile *objfile, htab_t copied_types)
{
value_object *iter;
static PyObject *
valpy_dereference (PyObject *self, PyObject *args)
{
- struct value *res_val = NULL; /* Initialize to appease gcc warning. */
- volatile struct gdb_exception except;
+ PyObject *result = NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
+ struct value *res_val;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
res_val = value_ind (((value_object *) self)->value);
+ result = value_to_value_object (res_val);
+ do_cleanups (cleanup);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- return value_to_value_object (res_val);
+ return result;
+}
+
+/* Given a value of a pointer type or a reference type, return the value
+ referenced. The difference between this function and valpy_dereference is
+ that the latter applies * unary operator to a value, which need not always
+ result in the value referenced. For example, for a value which is a reference
+ to an 'int' pointer ('int *'), valpy_dereference will result in a value of
+ type 'int' while valpy_referenced_value will result in a value of type
+ 'int *'. */
+
+static PyObject *
+valpy_referenced_value (PyObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+
+ TRY
+ {
+ struct value *self_val, *res_val;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
+ self_val = ((value_object *) self)->value;
+ switch (TYPE_CODE (check_typedef (value_type (self_val))))
+ {
+ case TYPE_CODE_PTR:
+ res_val = value_ind (self_val);
+ break;
+ case TYPE_CODE_REF:
+ res_val = coerce_ref (self_val);
+ break;
+ default:
+ error(_("Trying to get the referenced value from a value which is "
+ "neither a pointer nor a reference."));
+ }
+
+ result = value_to_value_object (res_val);
+ do_cleanups (cleanup);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return result;
+}
+
+/* Return a value which is a reference to the value. */
+
+static PyObject *
+valpy_reference_value (PyObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+
+ TRY
+ {
+ struct value *self_val;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
+ self_val = ((value_object *) self)->value;
+ result = value_to_value_object (value_ref (self_val));
+
+ do_cleanups (cleanup);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return result;
+}
+
+/* Return a "const" qualified version of the value. */
+
+static PyObject *
+valpy_const_value (PyObject *self, PyObject *args)
+{
+ PyObject *result = NULL;
+
+ TRY
+ {
+ struct value *self_val, *res_val;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
+ self_val = ((value_object *) self)->value;
+ res_val = make_cv_value (1, 0, self_val);
+ result = value_to_value_object (res_val);
+
+ do_cleanups (cleanup);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return result;
}
/* Return "&value". */
static PyObject *
valpy_get_address (PyObject *self, void *closure)
{
- struct value *res_val = NULL; /* Initialize to appease gcc warning. */
value_object *val_obj = (value_object *) self;
- volatile struct gdb_exception except;
if (!val_obj->address)
{
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
+ struct value *res_val;
+ struct cleanup *cleanup
+ = make_cleanup_value_free_to_mark (value_mark ());
+
res_val = value_addr (val_obj->value);
+ val_obj->address = value_to_value_object (res_val);
+ do_cleanups (cleanup);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
val_obj->address = Py_None;
Py_INCREF (Py_None);
}
- else
- val_obj->address = value_to_value_object (res_val);
+ END_CATCH
}
- Py_INCREF (val_obj->address);
+ Py_XINCREF (val_obj->address);
return val_obj->address;
}
valpy_get_dynamic_type (PyObject *self, void *closure)
{
value_object *obj = (value_object *) self;
- volatile struct gdb_exception except;
struct type *type = NULL;
if (obj->dynamic_type != NULL)
return obj->dynamic_type;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
struct value *val = obj->value;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
type = value_type (val);
CHECK_TYPEDEF (type);
if (((TYPE_CODE (type) == TYPE_CODE_PTR)
|| (TYPE_CODE (type) == TYPE_CODE_REF))
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
+ && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
{
struct value *target;
int was_pointer = TYPE_CODE (type) == TYPE_CODE_PTR;
- target = value_ind (val);
+ if (was_pointer)
+ target = value_ind (val);
+ else
+ target = coerce_ref (val);
type = value_rtti_type (target, NULL, NULL, NULL);
if (type)
type = lookup_reference_type (type);
}
}
- else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
+ else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
type = value_rtti_type (val, NULL, NULL, NULL);
else
{
/* Re-use object's static type. */
type = NULL;
}
- }
- GDB_PY_HANDLE_EXCEPTION (except);
- if (type == NULL)
+ do_cleanups (cleanup);
+ }
+ CATCH (except, RETURN_MASK_ALL)
{
- /* Ensure that the TYPE field is ready. */
- if (!valpy_get_type (self, NULL))
- return NULL;
- /* We don't need to incref here, because valpy_get_type already
- did it for us. */
- obj->dynamic_type = obj->type;
+ GDB_PY_HANDLE_EXCEPTION (except);
}
+ END_CATCH
+
+ if (type == NULL)
+ obj->dynamic_type = valpy_get_type (self, NULL);
else
obj->dynamic_type = type_to_type_object (type);
- Py_INCREF (obj->dynamic_type);
+ Py_XINCREF (obj->dynamic_type);
return obj->dynamic_type;
}
struct value *value = ((value_object *) self)->value;
const char *user_encoding = NULL;
static char *keywords[] = { "encoding", "length", NULL };
- PyObject *str_obj;
+ PyObject *str_obj = NULL;
if (!PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG, keywords,
&user_encoding, &length))
return NULL;
- if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
- value = value_ind (value);
+ TRY
+ {
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
+ if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
+ value = value_ind (value);
+
+ str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
+ user_encoding,
+ value_type (value));
- str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
- user_encoding,
- value_type (value));
+ do_cleanups (cleanup);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- return (PyObject *) str_obj;
+ return str_obj;
}
/* Implementation of gdb.Value.string ([encoding] [, errors]
int length = -1;
gdb_byte *buffer;
struct value *value = ((value_object *) self)->value;
- volatile struct gdb_exception except;
PyObject *unicode;
const char *encoding = NULL;
const char *errors = NULL;
&user_encoding, &errors, &length))
return NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
- unicode = PyUnicode_Decode (buffer, length * TYPE_LENGTH (char_type),
+ unicode = PyUnicode_Decode ((const char *) buffer,
+ length * TYPE_LENGTH (char_type),
encoding, errors);
xfree (buffer);
static PyObject *
valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op)
{
- PyObject *type_obj;
+ PyObject *type_obj, *result = NULL;
struct type *type;
- struct value *res_val = NULL; /* Initialize to appease gcc warning. */
- volatile struct gdb_exception except;
if (! PyArg_ParseTuple (args, "O", &type_obj))
return NULL;
type = type_object_to_type (type_obj);
if (! type)
{
- PyErr_SetString (PyExc_RuntimeError,
+ PyErr_SetString (PyExc_RuntimeError,
_("Argument must be a type."));
return NULL;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
struct value *val = ((value_object *) self)->value;
+ struct value *res_val;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
if (op == UNOP_DYNAMIC_CAST)
res_val = value_dynamic_cast (type, val);
gdb_assert (op == UNOP_CAST);
res_val = value_cast (type, val);
}
+
+ result = value_to_value_object (res_val);
+ do_cleanups (cleanup);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- return value_to_value_object (res_val);
+ return result;
}
/* Implementation of the "cast" method. */
return -1;
}
-/* Given string name of an element inside structure, return its value
- object. Returns NULL on error, with a python exception set. */
+/* Return 1 if the gdb.Field object FIELD is present in the value V.
+ Returns 0 otherwise. If any Python error occurs, -1 is returned. */
+
+static int
+value_has_field (struct value *v, PyObject *field)
+{
+ struct type *parent_type, *val_type;
+ enum type_code type_code;
+ PyObject *type_object = PyObject_GetAttrString (field, "parent_type");
+ int has_field = 0;
+
+ if (type_object == NULL)
+ return -1;
+
+ parent_type = type_object_to_type (type_object);
+ Py_DECREF (type_object);
+ if (parent_type == NULL)
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("'parent_type' attribute of gdb.Field object is not a"
+ "gdb.Type object."));
+ return -1;
+ }
+
+ TRY
+ {
+ val_type = value_type (v);
+ val_type = check_typedef (val_type);
+ if (TYPE_CODE (val_type) == TYPE_CODE_REF
+ || TYPE_CODE (val_type) == TYPE_CODE_PTR)
+ val_type = check_typedef (TYPE_TARGET_TYPE (val_type));
+
+ type_code = TYPE_CODE (val_type);
+ if ((type_code == TYPE_CODE_STRUCT || type_code == TYPE_CODE_UNION)
+ && types_equal (val_type, parent_type))
+ has_field = 1;
+ else
+ has_field = 0;
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_SET_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return has_field;
+}
+
+/* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
+ Returns 1 if the flag value is true, 0 if it is false, and -1 if
+ a Python error occurs. */
+
+static int
+get_field_flag (PyObject *field, const char *flag_name)
+{
+ int flag_value;
+ PyObject *flag_object = PyObject_GetAttrString (field, flag_name);
+
+ if (flag_object == NULL)
+ return -1;
+
+ flag_value = PyObject_IsTrue (flag_object);
+ Py_DECREF (flag_object);
+
+ return flag_value;
+}
+
+/* Return the "type" attribute of a gdb.Field object.
+ Returns NULL on error, with a Python exception set. */
+
+static struct type *
+get_field_type (PyObject *field)
+{
+ PyObject *ftype_obj = PyObject_GetAttrString (field, "type");
+ struct type *ftype;
+
+ if (ftype_obj == NULL)
+ return NULL;
+ ftype = type_object_to_type (ftype_obj);
+ Py_DECREF (ftype_obj);
+ if (ftype == NULL)
+ PyErr_SetString (PyExc_TypeError,
+ _("'type' attribute of gdb.Field object is not a "
+ "gdb.Type object."));
+
+ return ftype;
+}
+
+/* Given string name or a gdb.Field object corresponding to an element inside
+ a structure, return its value object. Returns NULL on error, with a python
+ exception set. */
+
static PyObject *
valpy_getitem (PyObject *self, PyObject *key)
{
+ struct gdb_exception except = exception_none;
value_object *self_value = (value_object *) self;
char *field = NULL;
- struct value *res_val = NULL;
- volatile struct gdb_exception except;
+ struct type *base_class_type = NULL, *field_type = NULL;
+ long bitpos = -1;
+ PyObject *result = NULL;
if (gdbpy_is_string (key))
- {
+ {
field = python_string_to_host_string (key);
if (field == NULL)
return NULL;
}
+ else if (gdbpy_is_field (key))
+ {
+ int is_base_class, valid_field;
+
+ valid_field = value_has_field (self_value->value, key);
+ if (valid_field < 0)
+ return NULL;
+ else if (valid_field == 0)
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Invalid lookup for a field not contained in "
+ "the value."));
+
+ return NULL;
+ }
+
+ is_base_class = get_field_flag (key, "is_base_class");
+ if (is_base_class < 0)
+ return NULL;
+ else if (is_base_class > 0)
+ {
+ base_class_type = get_field_type (key);
+ if (base_class_type == NULL)
+ return NULL;
+ }
+ else
+ {
+ PyObject *name_obj = PyObject_GetAttrString (key, "name");
+
+ if (name_obj == NULL)
+ return NULL;
+
+ if (name_obj != Py_None)
+ {
+ field = python_string_to_host_string (name_obj);
+ Py_DECREF (name_obj);
+ if (field == NULL)
+ return NULL;
+ }
+ else
+ {
+ PyObject *bitpos_obj;
+ int valid;
+
+ Py_DECREF (name_obj);
+
+ if (!PyObject_HasAttrString (key, "bitpos"))
+ {
+ PyErr_SetString (PyExc_AttributeError,
+ _("gdb.Field object has no name and no "
+ "'bitpos' attribute."));
+
+ return NULL;
+ }
+ bitpos_obj = PyObject_GetAttrString (key, "bitpos");
+ if (bitpos_obj == NULL)
+ return NULL;
+ valid = gdb_py_int_as_long (bitpos_obj, &bitpos);
+ Py_DECREF (bitpos_obj);
+ if (!valid)
+ return NULL;
+
+ field_type = get_field_type (key);
+ if (field_type == NULL)
+ return NULL;
+ }
+ }
+ }
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
struct value *tmp = self_value->value;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+ struct value *res_val = NULL;
if (field)
res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
+ else if (bitpos >= 0)
+ res_val = value_struct_elt_bitpos (&tmp, bitpos, field_type,
+ "struct/class/union");
+ else if (base_class_type != NULL)
+ {
+ struct type *val_type;
+
+ val_type = check_typedef (value_type (tmp));
+ if (TYPE_CODE (val_type) == TYPE_CODE_PTR)
+ res_val = value_cast (lookup_pointer_type (base_class_type), tmp);
+ else if (TYPE_CODE (val_type) == TYPE_CODE_REF)
+ res_val = value_cast (lookup_reference_type (base_class_type), tmp);
+ else
+ res_val = value_cast (base_class_type, tmp);
+ }
else
{
/* Assume we are attempting an array access, and let the
res_val = value_subscript (tmp, value_as_long (idx));
}
}
+
+ if (res_val)
+ result = value_to_value_object (res_val);
+ do_cleanups (cleanup);
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
}
+ END_CATCH
xfree (field);
GDB_PY_HANDLE_EXCEPTION (except);
- return res_val ? value_to_value_object (res_val) : NULL;
+ return result;
}
static int
static PyObject *
valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
{
- struct value *return_value = NULL;
Py_ssize_t args_count;
- volatile struct gdb_exception except;
struct value *function = ((value_object *) self)->value;
struct value **vargs = NULL;
- struct type *ftype = check_typedef (value_type (function));
+ struct type *ftype = NULL;
+ struct value *mark = value_mark ();
+ PyObject *result = NULL;
+
+ TRY
+ {
+ ftype = check_typedef (value_type (function));
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
if (TYPE_CODE (ftype) != TYPE_CODE_FUNC)
{
return NULL;
}
+ if (! PyTuple_Check (args))
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Inferior arguments must be provided in a tuple."));
+ return NULL;
+ }
+
args_count = PyTuple_Size (args);
if (args_count > 0)
{
}
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (mark);
+ struct value *return_value;
+
return_value = call_function_by_hand (function, args_count, vargs);
+ result = value_to_value_object (return_value);
+ do_cleanups (cleanup);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- return value_to_value_object (return_value);
+ return result;
}
/* Called by the Python interpreter to obtain string representation
valpy_str (PyObject *self)
{
char *s = NULL;
- struct ui_file *stb;
- struct cleanup *old_chain;
PyObject *result;
struct value_print_options opts;
- volatile struct gdb_exception except;
get_user_print_options (&opts);
opts.deref_ref = 0;
- stb = mem_fileopen ();
- old_chain = make_cleanup_ui_file_delete (stb);
-
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
+ struct ui_file *stb = mem_fileopen ();
+ struct cleanup *old_chain = make_cleanup_ui_file_delete (stb);
+
common_val_print (((value_object *) self)->value, stb, 0,
&opts, python_language);
s = ui_file_xstrdup (stb, NULL);
- }
- GDB_PY_HANDLE_EXCEPTION (except);
- do_cleanups (old_chain);
+ do_cleanups (old_chain);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL);
xfree (s);
valpy_get_is_optimized_out (PyObject *self, void *closure)
{
struct value *value = ((value_object *) self)->value;
+ int opt = 0;
+
+ TRY
+ {
+ opt = value_optimized_out (value);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ if (opt)
+ Py_RETURN_TRUE;
+
+ Py_RETURN_FALSE;
+}
+
+/* Implements gdb.Value.is_lazy. */
+static PyObject *
+valpy_get_is_lazy (PyObject *self, void *closure)
+{
+ struct value *value = ((value_object *) self)->value;
+ int opt = 0;
- if (value_optimized_out (value))
+ TRY
+ {
+ opt = value_lazy (value);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ if (opt)
Py_RETURN_TRUE;
Py_RETURN_FALSE;
}
+/* Implements gdb.Value.fetch_lazy (). */
+static PyObject *
+valpy_fetch_lazy (PyObject *self, PyObject *args)
+{
+ struct value *value = ((value_object *) self)->value;
+
+ TRY
+ {
+ if (value_lazy (value))
+ value_fetch_lazy (value);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ Py_RETURN_NONE;
+}
+
/* Calculate and return the address of the PyObject as the value of
the builtin __hash__ call. */
-static long
+static Py_hash_t
valpy_hash (PyObject *self)
{
- return (long) (intptr_t) self;
+ return (intptr_t) self;
}
enum valpy_opcode
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;
+ PyObject *result = NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
struct value *arg1, *arg2;
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+ struct value *res_val = NULL;
+ enum exp_opcode op = OP_NULL;
+ int handled = 0;
/* 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
a gdb.Value object and need to convert it from python as well. */
arg1 = convert_value_from_python (self);
if (arg1 == NULL)
- break;
+ {
+ do_cleanups (cleanup);
+ break;
+ }
arg2 = convert_value_from_python (other);
if (arg2 == NULL)
- break;
+ {
+ do_cleanups (cleanup);
+ break;
+ }
switch (opcode)
{
CHECK_TYPEDEF (rtype);
rtype = STRIP_REFERENCE (rtype);
+ handled = 1;
if (TYPE_CODE (ltype) == TYPE_CODE_PTR
&& is_integral_type (rtype))
res_val = value_ptradd (arg1, value_as_long (arg2));
&& is_integral_type (ltype))
res_val = value_ptradd (arg2, value_as_long (arg1));
else
- res_val = value_binop (arg1, arg2, BINOP_ADD);
+ {
+ handled = 0;
+ op = BINOP_ADD;
+ }
}
break;
case VALPY_SUB:
CHECK_TYPEDEF (rtype);
rtype = STRIP_REFERENCE (rtype);
+ handled = 1;
if (TYPE_CODE (ltype) == TYPE_CODE_PTR
&& TYPE_CODE (rtype) == TYPE_CODE_PTR)
/* A ptrdiff_t for the target would be preferable here. */
&& is_integral_type (rtype))
res_val = value_ptradd (arg1, - value_as_long (arg2));
else
- res_val = value_binop (arg1, arg2, BINOP_SUB);
+ {
+ handled = 0;
+ op = BINOP_SUB;
+ }
}
break;
case VALPY_MUL:
- res_val = value_binop (arg1, arg2, BINOP_MUL);
+ op = BINOP_MUL;
break;
case VALPY_DIV:
- res_val = value_binop (arg1, arg2, BINOP_DIV);
+ op = BINOP_DIV;
break;
case VALPY_REM:
- res_val = value_binop (arg1, arg2, BINOP_REM);
+ op = BINOP_REM;
break;
case VALPY_POW:
- res_val = value_binop (arg1, arg2, BINOP_EXP);
+ op = BINOP_EXP;
break;
case VALPY_LSH:
- res_val = value_binop (arg1, arg2, BINOP_LSH);
+ op = BINOP_LSH;
break;
case VALPY_RSH:
- res_val = value_binop (arg1, arg2, BINOP_RSH);
+ op = BINOP_RSH;
break;
case VALPY_BITAND:
- res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
+ op = BINOP_BITWISE_AND;
break;
case VALPY_BITOR:
- res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
+ op = BINOP_BITWISE_IOR;
break;
case VALPY_BITXOR:
- res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
+ op = BINOP_BITWISE_XOR;
break;
}
+
+ if (!handled)
+ {
+ if (binop_user_defined_p (op, arg1, arg2))
+ res_val = value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
+ else
+ res_val = value_binop (arg1, arg2, op);
+ }
+
+ if (res_val)
+ result = value_to_value_object (res_val);
+
+ do_cleanups (cleanup);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- return res_val ? value_to_value_object (res_val) : NULL;
+ return result;
}
static PyObject *
static PyObject *
valpy_negative (PyObject *self)
{
- struct value *val = NULL;
- volatile struct gdb_exception except;
+ PyObject *result = NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
+ /* Perhaps overkill, but consistency has some virtue. */
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+ struct value *val;
+
val = value_neg (((value_object *) self)->value);
+ result = value_to_value_object (val);
+ do_cleanups (cleanup);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- return value_to_value_object (val);
+ return result;
}
static PyObject *
valpy_absolute (PyObject *self)
{
struct value *value = ((value_object *) self)->value;
+ int isabs = 1;
- if (value_less (value, value_zero (value_type (value), not_lval)))
- return valpy_negative (self);
- else
+ TRY
+ {
+ struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
+ if (value_less (value, value_zero (value_type (value), not_lval)))
+ isabs = 0;
+
+ do_cleanups (cleanup);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ if (isabs)
return valpy_positive (self);
+ else
+ return valpy_negative (self);
}
/* Implements boolean evaluation of gdb.Value. */
static int
valpy_nonzero (PyObject *self)
{
+ struct gdb_exception except = exception_none;
value_object *self_value = (value_object *) self;
struct type *type;
+ int nonzero = 0; /* Appease GCC warning. */
+
+ TRY
+ {
+ type = check_typedef (value_type (self_value->value));
+
+ if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
+ nonzero = !!value_as_long (self_value->value);
+ else if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ nonzero = value_as_double (self_value->value) != 0;
+ else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
+ nonzero = !decimal_is_zero (value_contents (self_value->value),
+ TYPE_LENGTH (type),
+ gdbarch_byte_order (get_type_arch (type)));
+ else
+ /* All other values are True. */
+ nonzero = 1;
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
+ }
+ END_CATCH
- type = check_typedef (value_type (self_value->value));
+ /* This is not documented in the Python documentation, but if this
+ function fails, return -1 as slot_nb_nonzero does (the default
+ Python nonzero function). */
+ GDB_PY_SET_HANDLE_EXCEPTION (except);
- 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),
- gdbarch_byte_order (get_type_arch (type)));
- else
- /* All other values are True. */
- return 1;
+ return nonzero;
}
/* Implements ~ for value objects. */
valpy_invert (PyObject *self)
{
struct value *val = NULL;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
val = value_complement (((value_object *) self)->value);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return value_to_value_object (val);
}
valpy_richcompare (PyObject *self, PyObject *other, int op)
{
int result = 0;
- struct value *value_other;
- volatile struct gdb_exception except;
if (other == Py_None)
/* Comparing with None is special. From what I can tell, in Python
return NULL;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
+ struct value *value_other, *mark = value_mark ();
+ struct cleanup *cleanup;
+
value_other = convert_value_from_python (other);
if (value_other == NULL)
{
break;
}
+ cleanup = make_cleanup_value_free_to_mark (mark);
+
switch (op) {
case Py_LT:
result = value_less (((value_object *) self)->value, value_other);
result = -1;
break;
}
+
+ do_cleanups (cleanup);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
/* In this case, the Python exception has already been set. */
if (result < 0)
Py_RETURN_FALSE;
}
-/* Helper function to determine if a type is "int-like". */
-static int
-is_intlike (struct type *type, int ptr_ok)
-{
- CHECK_TYPEDEF (type);
- return (TYPE_CODE (type) == TYPE_CODE_INT
- || TYPE_CODE (type) == TYPE_CODE_ENUM
- || TYPE_CODE (type) == TYPE_CODE_BOOL
- || TYPE_CODE (type) == TYPE_CODE_CHAR
- || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
-}
-
+#ifndef IS_PY3K
/* Implements conversion to int. */
static PyObject *
valpy_int (PyObject *self)
struct value *value = ((value_object *) self)->value;
struct type *type = value_type (value);
LONGEST l = 0;
- volatile struct gdb_exception except;
- CHECK_TYPEDEF (type);
- if (!is_intlike (type, 0))
+ TRY
{
- PyErr_SetString (PyExc_RuntimeError,
- _("Cannot convert value to int."));
- return NULL;
- }
+ if (!is_integral_type (type))
+ error (_("Cannot convert value to int."));
- TRY_CATCH (except, RETURN_MASK_ALL)
- {
l = value_as_long (value);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return gdb_py_object_from_longest (l);
}
+#endif
/* Implements conversion to long. */
static PyObject *
struct value *value = ((value_object *) self)->value;
struct type *type = value_type (value);
LONGEST l = 0;
- volatile struct gdb_exception except;
- if (!is_intlike (type, 1))
+ TRY
{
- PyErr_SetString (PyExc_RuntimeError,
- _("Cannot convert value to long."));
- return NULL;
- }
+ CHECK_TYPEDEF (type);
+
+ if (!is_integral_type (type)
+ && TYPE_CODE (type) != TYPE_CODE_PTR)
+ error (_("Cannot convert value to long."));
- TRY_CATCH (except, RETURN_MASK_ALL)
- {
l = value_as_long (value);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return gdb_py_long_from_longest (l);
}
struct value *value = ((value_object *) self)->value;
struct type *type = value_type (value);
double d = 0;
- volatile struct gdb_exception except;
- CHECK_TYPEDEF (type);
- if (TYPE_CODE (type) != TYPE_CODE_FLT)
+ TRY
{
- PyErr_SetString (PyExc_RuntimeError,
- _("Cannot convert value to float."));
- return NULL;
- }
+ CHECK_TYPEDEF (type);
+
+ if (TYPE_CODE (type) != TYPE_CODE_FLT)
+ error (_("Cannot convert value to float."));
- TRY_CATCH (except, RETURN_MASK_ALL)
- {
d = value_as_double (value);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return PyFloat_FromDouble (d);
}
if (val_obj != NULL)
{
val_obj->value = val;
- value_incref (val);
+ release_value_or_incref (val);
val_obj->address = NULL;
val_obj->type = NULL;
val_obj->dynamic_type = NULL;
convert_value_from_python (PyObject *obj)
{
struct value *value = NULL; /* -Wall */
- struct cleanup *old;
- volatile struct gdb_exception except;
int cmp;
gdb_assert (obj != NULL);
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- if (PyBool_Check (obj))
+ if (PyBool_Check (obj))
{
cmp = PyObject_IsTrue (obj);
if (cmp >= 0)
value = value_from_longest (builtin_type_pybool, cmp);
}
- else if (PyInt_Check (obj))
- {
- long l = PyInt_AsLong (obj);
-
- if (! PyErr_Occurred ())
- value = value_from_longest (builtin_type_pyint, l);
- }
+ /* Make a long logic check first. In Python 3.x, internally,
+ all integers are represented as longs. In Python 2.x, there
+ is still a differentiation internally between a PyInt and a
+ PyLong. Explicitly do this long check conversion first. In
+ GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
+ to be done first to ensure we do not lose information in the
+ conversion process. */
else if (PyLong_Check (obj))
{
LONGEST l = PyLong_AsLongLong (obj);
else
value = value_from_longest (builtin_type_pylong, l);
}
+ else if (PyInt_Check (obj))
+ {
+ long l = PyInt_AsLong (obj);
+
+ if (! PyErr_Occurred ())
+ value = value_from_longest (builtin_type_pyint, l);
+ }
else if (PyFloat_Check (obj))
{
double d = PyFloat_AsDouble (obj);
s = python_string_to_target_string (obj);
if (s != NULL)
{
+ struct cleanup *old;
+
old = make_cleanup (xfree, s);
value = value_cstring (s, strlen (s), builtin_type_pychar);
do_cleanups (old);
value = value_copy (((value_object *) result)->value);
}
else
+#ifdef IS_PY3K
+ PyErr_Format (PyExc_TypeError,
+ _("Could not convert Python object: %S."), obj);
+#else
PyErr_Format (PyExc_TypeError,
_("Could not convert Python object: %s."),
PyString_AsString (PyObject_Str (obj)));
+#endif
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
PyErr_Format (except.reason == RETURN_QUIT
? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
"%s", except.message);
return NULL;
}
+ END_CATCH
return value;
}
{
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)
+ TRY
{
res_val = access_value_history (i);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return value_to_value_object (res_val);
}
return PyObject_TypeCheck (obj, &value_object_type);
}
-void
+int
gdbpy_initialize_values (void)
{
if (PyType_Ready (&value_object_type) < 0)
- return;
+ return -1;
- Py_INCREF (&value_object_type);
- PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
-
- values_in_python = NULL;
+ return gdb_pymodule_addobject (gdb_module, "Value",
+ (PyObject *) &value_object_type);
}
\f
{ "type", valpy_get_type, NULL, "Type of the value.", NULL },
{ "dynamic_type", valpy_get_dynamic_type, NULL,
"Dynamic type of the value.", NULL },
+ { "is_lazy", valpy_get_is_lazy, NULL,
+ "Boolean telling whether the value is lazy (not fetched yet\n\
+from the inferior). A lazy value is fetched when needed, or when\n\
+the \"fetch_lazy()\" method is called.", NULL },
{NULL} /* Sentinel */
};
reinterpret_cast operator."
},
{ "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
+ { "referenced_value", valpy_referenced_value, METH_NOARGS,
+ "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
+ { "reference_value", valpy_reference_value, METH_NOARGS,
+ "Return a value of type TYPE_CODE_REF referencing this value." },
+ { "const_value", valpy_const_value, METH_NOARGS,
+ "Return a 'const' qualied version of the same value." },
{ "lazy_string", (PyCFunction) valpy_lazy_string,
METH_VARARGS | METH_KEYWORDS,
"lazy_string ([encoding] [, length]) -> lazy_string\n\
{ "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
"string ([encoding] [, errors] [, length]) -> string\n\
Return Unicode string representation of the value." },
+ { "fetch_lazy", valpy_fetch_lazy, METH_NOARGS,
+ "Fetches the value from the inferior, if it was lazy." },
{NULL} /* Sentinel */
};
valpy_add,
valpy_subtract,
valpy_multiply,
+#ifndef IS_PY3K
valpy_divide,
+#endif
valpy_remainder,
NULL, /* nb_divmod */
valpy_power, /* nb_power */
valpy_and, /* nb_and */
valpy_xor, /* nb_xor */
valpy_or, /* nb_or */
+#ifdef IS_PY3K
+ valpy_long, /* nb_int */
+ NULL, /* reserved */
+#else
NULL, /* nb_coerce */
valpy_int, /* nb_int */
valpy_long, /* nb_long */
+#endif
valpy_float, /* nb_float */
+#ifndef IS_PY3K
NULL, /* nb_oct */
- NULL /* nb_hex */
+ NULL, /* nb_hex */
+#endif
+ NULL, /* nb_inplace_add */
+ NULL, /* nb_inplace_subtract */
+ NULL, /* nb_inplace_multiply */
+ NULL, /* nb_inplace_remainder */
+ NULL, /* nb_inplace_power */
+ NULL, /* nb_inplace_lshift */
+ NULL, /* nb_inplace_rshift */
+ NULL, /* nb_inplace_and */
+ NULL, /* nb_inplace_xor */
+ NULL, /* nb_inplace_or */
+ NULL, /* nb_floor_divide */
+ valpy_divide /* nb_true_divide */
};
static PyMappingMethods value_object_as_mapping = {
};
PyTypeObject value_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Value", /*tp_name*/
sizeof (value_object), /*tp_basicsize*/
0, /*tp_itemsize*/
0, /* tp_alloc */
valpy_new /* tp_new */
};
-
-#else
-
-void
-preserve_python_values (struct objfile *objfile, htab_t copied_types)
-{
- /* Nothing. */
-}
-
-#endif /* HAVE_PYTHON */
projects / deliverable / binutils-gdb.git / blobdiff