** New function gdb.notify_mi(NAME, DATA), that emits custom
GDB/MI async notification.
+ ** New read/write attribute gdb.Value.bytes that contains a bytes
+ object holding the contents of this value.
+
*** Changes in GDB 14
* GDB now supports the AArch64 Scalable Matrix Extension 2 (SME2), which
method is invoked.
@end defvar
+@defvar Value.bytes
+The value of this attribute is a @code{bytes} object containing the
+bytes that make up this @code{Value}'s complete value in little endian
+order. If the complete contents of this value are not available then
+accessing this attribute will raise an exception.
+
+This attribute can also be assigned to. The new value should be a
+buffer object (e.g.@: a @code{bytes} object), the length of the new
+buffer must exactly match the length of this @code{Value}'s type. The
+bytes values in the new buffer should be in little endian order.
+
+As with @code{Value.assign} (@pxref{Value.assign}), if this value
+cannot be assigned to, then an exception will be thrown.
+@end defvar
+
The following methods are provided:
@defun Value.__init__ (val)
behaves as though @var{type} was not passed at all.
@end defun
+@anchor{Value.assign}
@defun Value.assign (rhs)
Assign @var{rhs} to this value, and return @code{None}. If this value
cannot be assigned to, or if the assignment is invalid for some reason
PyObject *address;
PyObject *type;
PyObject *dynamic_type;
+ PyObject *content_bytes;
};
/* List of all values which are currently exposed to Python. It is
Py_CLEAR (self->address);
Py_CLEAR (self->type);
Py_CLEAR (self->dynamic_type);
+ Py_CLEAR (self->content_bytes);
}
/* Called by the Python interpreter when deallocating a value object. */
/* Convert a python object OBJ with type TYPE to a gdb value. The
python object in question must conform to the python buffer
protocol. On success, return the converted value, otherwise
- nullptr. */
+ nullptr. When REQUIRE_EXACT_SIZE_P is true the buffer OBJ must be the
+ exact length of TYPE. When REQUIRE_EXACT_SIZE_P is false then the
+ buffer OBJ can be longer than TYPE, in which case only the least
+ significant bytes from the buffer are used. */
static struct value *
-convert_buffer_and_type_to_value (PyObject *obj, struct type *type)
+convert_buffer_and_type_to_value (PyObject *obj, struct type *type,
+ bool require_exact_size_p)
{
Py_buffer_up buffer_up;
Py_buffer py_buf;
return nullptr;
}
- if (type->length () > py_buf.len)
+ if (require_exact_size_p && type->length () != py_buf.len)
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("Size of type is not equal to that of buffer object."));
+ return nullptr;
+ }
+ else if (!require_exact_size_p && type->length () > py_buf.len)
{
PyErr_SetString (PyExc_ValueError,
_("Size of type is larger than that of buffer object."));
if (type == nullptr)
value = convert_value_from_python (val_obj);
else
- value = convert_buffer_and_type_to_value (val_obj, type);
+ value = convert_buffer_and_type_to_value (val_obj, type, false);
if (value == nullptr)
{
gdb_assert (PyErr_Occurred ());
return valpy_do_cast (self, args, UNOP_REINTERPRET_CAST);
}
-/* Implementation of the "assign" method. */
+/* Assign NEW_VALUE into SELF, handles 'struct value' reference counting,
+ and also clearing the bytes data cached within SELF. Return true if
+ the assignment was successful, otherwise return false, in which case a
+ Python exception will be set. */
-static PyObject *
-valpy_assign (PyObject *self_obj, PyObject *args)
+static bool
+valpy_assign_core (value_object *self, struct value *new_value)
{
- PyObject *val_obj;
-
- if (! PyArg_ParseTuple (args, "O", &val_obj))
- return nullptr;
-
- struct value *val = convert_value_from_python (val_obj);
- if (val == nullptr)
- return nullptr;
-
try
{
- value_object *self = (value_object *) self_obj;
- value *new_value = value_assign (self->value, val);
+ new_value = value_assign (self->value, new_value);
+
/* value_as_address returns a new value with the same location
as the old one. Ensure that this gdb.Value is updated to
reflect the new value. */
new_value->incref ();
self->value->decref ();
+ Py_CLEAR (self->content_bytes);
self->value = new_value;
}
catch (const gdb_exception &except)
{
- GDB_PY_HANDLE_EXCEPTION (except);
+ gdbpy_convert_exception (except);
+ return false;
}
+ return true;
+}
+
+/* Implementation of the "assign" method. */
+
+static PyObject *
+valpy_assign (PyObject *self_obj, PyObject *args)
+{
+ PyObject *val_obj;
+
+ if (! PyArg_ParseTuple (args, "O", &val_obj))
+ return nullptr;
+
+ struct value *val = convert_value_from_python (val_obj);
+ if (val == nullptr)
+ return nullptr;
+
+ value_object *self = (value_object *) self_obj;
+ if (!valpy_assign_core (self, val))
+ return nullptr;
+
Py_RETURN_NONE;
}
Py_RETURN_FALSE;
}
+/* Get gdb.Value.bytes attribute. */
+
+static PyObject *
+valpy_get_bytes (PyObject *self, void *closure)
+{
+ value_object *value_obj = (value_object *) self;
+ struct value *value = value_obj->value;
+
+ if (value_obj->content_bytes != nullptr)
+ {
+ Py_INCREF (value_obj->content_bytes);
+ return value_obj->content_bytes;
+ }
+
+ gdb::array_view<const gdb_byte> contents;
+ try
+ {
+ contents = value->contents ();
+ }
+ catch (const gdb_exception &except)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+
+ value_obj->content_bytes
+ = PyBytes_FromStringAndSize ((const char *) contents.data (),
+ contents.size ());
+ Py_XINCREF (value_obj->content_bytes);
+ return value_obj->content_bytes;
+}
+
+/* Set gdb.Value.bytes attribute. */
+
+static int
+valpy_set_bytes (PyObject *self_obj, PyObject *new_value_obj, void *closure)
+{
+ value_object *self = (value_object *) self_obj;
+
+ /* Create a new value from the buffer NEW_VALUE_OBJ. We pass true here
+ to indicate that NEW_VALUE_OBJ must match exactly the type length. */
+ struct value *new_value
+ = convert_buffer_and_type_to_value (new_value_obj, self->value->type (),
+ true);
+ if (new_value == nullptr)
+ return -1;
+
+ if (!valpy_assign_core (self, new_value))
+ return -1;
+
+ return 0;
+}
+
/* Implements gdb.Value.fetch_lazy (). */
static PyObject *
valpy_fetch_lazy (PyObject *self, PyObject *args)
val_obj->address = NULL;
val_obj->type = NULL;
val_obj->dynamic_type = NULL;
+ val_obj->content_bytes = nullptr;
note_value (val_obj);
}
"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 },
+ { "bytes", valpy_get_bytes, valpy_set_bytes,
+ "Return a bytearray containing the bytes of this value.", nullptr },
{NULL} /* Sentinel */
};
gdb_test "python print ('result = %s' % i.address)" "= None" "test address attribute in non-addressable value"
# Test creating / printing an optimized out value
- gdb_test "python print(gdb.Value(gdb.Value(5).type.optimized_out()))"
+ gdb_test "python print(gdb.Value(gdb.Value(5).type.optimized_out()))" \
+ "<optimized out>"
}
# Check that we can call gdb.Value.__init__ to change a value.
proc test_value_from_buffer {} {
global gdb_prompt
+ # A Python helper function. Create a bytes object from inferior
+ # memory LEN bytes starting at ADDR, and compare this to the bytes
+ # obtained from VAL.bytes. Assert that the two bytes object match.
+ gdb_test_multiline "Create another function to check Value.bytes" \
+ "python" "" \
+ "def compare_value_bytes_to_mem(val, addr, len):" "" \
+ " mem = gdb.selected_inferior().read_memory(addr, len)" "" \
+ " mem_bytes = mem.tobytes()" "" \
+ " val_bytes = val.bytes" "" \
+ " assert mem_bytes == val_bytes" "" \
+ "end" ""
+
prepare_type_and_buffer
gdb_test "python v=gdb.Value(b,tp); print(v)" "1" \
"construct value from buffer"
+ gdb_test_no_output { python compare_value_bytes_to_mem(v, addr, size_a0) }
gdb_test "python v=gdb.Value(b\[size_a0:\],tp); print(v)" "2" \
"convert 2nd elem of buffer to value"
+ gdb_test_no_output \
+ { python compare_value_bytes_to_mem(v, (int(addr) + size_a0), size_a0) }
gdb_test "python v=gdb.Value(b\[2*size_a0:\],tp); print(v)" "3" \
"convert 3rd elem of buffer to value"
+ gdb_test_no_output \
+ { python compare_value_bytes_to_mem(v, (int(addr) + (2 * size_a0)), size_a0) }
gdb_test "python v=gdb.Value(b\[2*size_a0+1:\],tp); print(v)" \
"ValueError: Size of type is larger than that of buffer object\..*" \
"attempt to convert smaller buffer than size of type"
"make array type" 0
gdb_py_test_silent_cmd "python va=gdb.Value(b,atp)" \
"construct array value from buffer" 0
+ gdb_test_no_output \
+ { python compare_value_bytes_to_mem(va, addr, size_a0 * 3) }
gdb_test "python print(va)" "\\{1, 2, 3\\}" "print array value"
gdb_test "python print(va\[0\])" "1" "print first array element"
gdb_test "python print(va\[1\])" "2" "print second array element"
}
}
+# Test the gdb.Value.bytes API.
+proc_with_prefix test_value_bytes { } {
+ # Test accessing the bytes of an optimised out value.
+ gdb_test "python print(gdb.Value(gdb.Value(5).type.optimized_out()).bytes)" \
+ [multi_line \
+ "gdb\\.error: value has been optimized out" \
+ "Error while executing Python code\\."]
+
+ # A Python helper function. Fetch VAR_NAME from the inferior as a
+ # gdb.Value. Read the bytes of the value based on its address, and
+ # the size of its type. The compare these bytes to the value
+ # obtained from gdb.Value.bytes. Assert that the two bytes objects
+ # match.
+ gdb_test_multiline "Create a function to check Value.bytes" \
+ "python" "" \
+ "def check_value_bytes(var_name):" "" \
+ " val = gdb.parse_and_eval(var_name)" "" \
+ " addr = val.address" "" \
+ " len = val.type.sizeof" "" \
+ " mem = gdb.selected_inferior().read_memory(addr, len)" "" \
+ " mem_bytes = mem.tobytes()" "" \
+ " val_bytes = val.bytes" "" \
+ " assert mem_bytes == val_bytes" "" \
+ "end" ""
+
+ gdb_test_no_output { python check_value_bytes("a") }
+ gdb_test_no_output { python check_value_bytes("p") }
+ gdb_test_no_output { python check_value_bytes("i") }
+ gdb_test_no_output { python check_value_bytes("ptr_i") }
+ gdb_test_no_output { python check_value_bytes("embed") }
+ gdb_test_no_output { python check_value_bytes("fp1") }
+ gdb_test_no_output { python check_value_bytes("nullst") }
+ gdb_test_no_output { python check_value_bytes("st") }
+ gdb_test_no_output { python check_value_bytes("s") }
+ gdb_test_no_output { python check_value_bytes("u") }
+
+ # Check that gdb.Value.bytes changes after calling
+ # gdb.Value.assign(). The bytes value is cached within the Value
+ # object, so calling assign should clear the cache.
+ with_test_prefix "assign clears bytes cache" {
+ gdb_test_no_output "python v = gdb.parse_and_eval(\"i\")"
+ gdb_test_no_output "python bytes_before = v.bytes"
+ gdb_test_no_output "python v.assign(9)"
+ gdb_test_no_output "python bytes_after = v.bytes"
+ gdb_test_no_output "python assert(bytes_after != bytes_before)"
+ }
+
+ # Check that if we re-init a gdb.Value object the cached bytes for
+ # the Value are cleared.
+ with_test_prefix "re-init clears bytes cache" {
+ gdb_test_no_output "python w = gdb.Value(1)"
+ gdb_test_no_output "python bytes_before = w.bytes"
+ gdb_test_no_output "python w.__init__(3)"
+ gdb_test_no_output "python bytes_after = w.bytes"
+ gdb_test_no_output "python assert(bytes_after != bytes_before)"
+ }
+
+ # Check that we can assign to the Value.bytes field.
+ gdb_test_no_output "python i_value = gdb.parse_and_eval('i')" \
+ "evaluate i"
+ gdb_test_no_output "python i_bytes = i_value.bytes"
+ gdb_test_no_output "python i_bytes = bytes(\[b if b != 9 else 5 for b in i_bytes\])"
+ gdb_test_no_output "python i_value.bytes = i_bytes"
+ gdb_test "print i" " = 5"
+
+ # Check we get an exception if attempting to assign a buffer that is
+ # too big, or too small.
+ gdb_test_no_output "python bytes_as_int = \[x for x in i_bytes\]"
+ gdb_test_no_output "python bytes_as_int.append(0)"
+ gdb_test_no_output "python too_many_bytes = bytes(bytes_as_int)"
+ gdb_test "python i_value.bytes = too_many_bytes" \
+ "ValueError: Size of type is not equal to that of buffer object\\..*"
+ gdb_test_no_output "python bytes_as_int = bytes_as_int\[0:-2\]"
+ gdb_test_no_output "python too_few_bytes = bytes(bytes_as_int)"
+ gdb_test "python i_value.bytes = too_few_bytes" \
+ "ValueError: Size of type is not equal to that of buffer object\\..*"
+
+ # Check we get an exception writing to a not_lval.
+ gdb_test_no_output "python i_value = gdb.Value(9)" \
+ "reset i_value"
+ gdb_test_no_output "python i_bytes = i_value.bytes" \
+ "grab new value bytes"
+ gdb_test "python i_value.bytes = i_bytes" "not an lvalue.*" \
+ "cannot assign to not_lval value"
+}
+
# Test Value.assign.
proc test_assign {} {
gdb_test_no_output "python i_value = gdb.parse_and_eval('i')" \
test_value_sub_classes
test_inferior_function_call
test_assign
+test_value_bytes
test_value_after_death
# Test either C or C++ values.
projects / binutils-gdb.git / commitdiff