From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1726) id A0FC0385840F; Thu, 30 Mar 2023 09:26:32 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A0FC0385840F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1680168392; bh=2Ljk84DXofPxyMxuSbfd8GSsdhyYGjNg8SJTCkDjLzA=; h=From:To:Subject:Date:From; b=FYq64RD46JGmpyaQJJ8l1W1GuJUzwLkvGwmifuW9N18aalgsEt7WUKlxFt3HcZ05i vcu8eXkJnf/92d2Wi8Y4XemR8voGS8ABwV0TosZXmdALot1l3tp3vjBg+Iya0GP/24 sREX8qaouwigWhin0pEeVIavX3pYc9/i2yHTkA48= Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Andrew Burgess To: gdb-cvs@sourceware.org Subject: [binutils-gdb] gdb/python: Allow gdb.UnwindInfo to be created with non gdb.Value args X-Act-Checkin: binutils-gdb X-Git-Author: Andrew Burgess X-Git-Refname: refs/heads/master X-Git-Oldrev: f4d9bc8356ebee51b91d6144acdd49a572c6aba6 X-Git-Newrev: 64826d05d3ccc487009312958de5d83752b2867a Message-Id: <20230330092632.A0FC0385840F@sourceware.org> Date: Thu, 30 Mar 2023 09:26:32 +0000 (GMT) List-Id: https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D64826d05d3cc= c487009312958de5d83752b2867a commit 64826d05d3ccc487009312958de5d83752b2867a Author: Andrew Burgess Date: Fri Mar 10 11:29:39 2023 +0000 gdb/python: Allow gdb.UnwindInfo to be created with non gdb.Value args =20 Currently when creating a gdb.UnwindInfo object a user must call gdb.PendingFrame.create_unwind_info and pass a frame-id object. =20 The frame-id object should have at least a 'sp' attribute, and probably a 'pc' attribute too (it can also, in some cases have a 'special' attribute). =20 Currently all of these frame-id attributes need to be gdb.Value objects, but the only reason for that requirement is that we have some code in py-unwind.c that only handles gdb.Value objects. =20 If instead we switch to using get_addr_from_python in py-utils.c then we will support both gdb.Value objects and also raw numbers, which might make things simpler in some cases. =20 So, I started rewriting pyuw_object_attribute_to_pointer (in py-unwind.c) to use get_addr_from_python. However, while looking at the code I noticed a problem. =20 The pyuw_object_attribute_to_pointer function returns a boolean flag, if everything goes OK we return true, but we return false in two cases, (1) when the attribute is not present, which might be acceptable, or might be an error, and (2) when we get an error trying to extract the attribute value, in which case a Python error will have been set. =20 Now in pending_framepy_create_unwind_info we have this code: =20 if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "sp", &sp)) { PyErr_SetString (PyExc_ValueError, _("frame_id should have 'sp' attribute.")); return NULL; } =20 Notice how we always set an error. This will override any error that is already set. =20 So, if you create a frame-id object that has an 'sp' attribute, but the attribute is not a gdb.Value, then currently we fail to extract the attribute value (it's not a gdb.Value) and set this error in pyuw_object_attribute_to_pointer: =20 rc =3D pyuw_value_obj_to_pointer (pyo_value.get (), addr); if (!rc) PyErr_Format ( PyExc_ValueError, _("The value of the '%s' attribute is not a pointer."), attr_name); =20 Then we return to pending_framepy_create_unwind_info and immediately override this error with the error about 'sp' being missing. =20 This all feels very confused. =20 Here's my proposed solution: pyuw_object_attribute_to_pointer will now return a tri-state enum, with states OK, MISSING, or ERROR. The meanings of these states are: =20 OK - Attribute exists and was extracted fine, =20 MISSING - Attribute doesn't exist, no Python error was set. =20 ERROR - Attribute does exist, but there was an error while extracting it, a Python error was set. =20 We need to update pending_framepy_create_unwind_info, the only user of pyuw_object_attribute_to_pointer, but now I think things are much clearer. Errors from lower levels are not blindly overridden with the generic meaningless error message, but we still get the "missing 'sp' attribute" error when appropriate. =20 This change also includes the switch to get_addr_from_python which was what started this whole journey. =20 For well behaving user code there should be no visible changes after this commit. =20 For user code that hits an error, hopefully the new errors should be more helpful in figuring out what's gone wrong. =20 Additionally, users can now use integers for the 'sp' and 'pc' attributes in their frame-id objects if that is useful. =20 Reviewed-By: Tom Tromey Diff: --- gdb/NEWS | 4 ++ gdb/doc/python.texi | 3 +- gdb/python/py-unwind.c | 113 +++++++++++++++++++----------= ---- gdb/testsuite/gdb.python/py-unwind.exp | 36 +++++++++++ gdb/testsuite/gdb.python/py-unwind.py | 6 +- 5 files changed, 111 insertions(+), 51 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index d5316ffef60..043847f6ed6 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -140,6 +140,10 @@ show always-read-ctf - gdb.PendingFrame.function: Return a gdb.Symbol for the current pending frame, or None. =20 + ** The frame-id passed to gdb.PendingFrame.create_unwind_info can + now use either an integer or a gdb.Value object for each of its + 'sp', 'pc', and 'special' attributes. + *** Changes in GDB 13 =20 * MI version 1 is deprecated, and will be removed in GDB 14. diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi index 80697f92564..b41432ae3cf 100644 --- a/gdb/doc/python.texi +++ b/gdb/doc/python.texi @@ -2815,7 +2815,8 @@ Inside gdb, this is called a ``wild frame''. You wil= l never need this. @end table =20 -Each attribute value should be an instance of @code{gdb.Value}. +Each attribute value should either be an instance of @code{gdb.Value} +or an integer. =20 @end defun =20 diff --git a/gdb/python/py-unwind.c b/gdb/python/py-unwind.c index 432a26a760a..409dbd3a470 100644 --- a/gdb/python/py-unwind.c +++ b/gdb/python/py-unwind.c @@ -132,58 +132,63 @@ extern PyTypeObject pending_frame_object_type extern PyTypeObject unwind_info_object_type CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("unwind_info_object"); =20 -/* Convert gdb.Value instance to inferior's pointer. Return 1 on success, - 0 on failure. */ +/* An enum returned by pyuw_object_attribute_to_pointer, a function which + is used to extract an attribute from a Python object. */ =20 -static int -pyuw_value_obj_to_pointer (PyObject *pyo_value, CORE_ADDR *addr) +enum class pyuw_get_attr_code { - int rc =3D 0; - struct value *value; + /* The attribute was present, and its value was successfully extracted. = */ + ATTR_OK, =20 - try - { - if ((value =3D value_object_to_value (pyo_value)) !=3D NULL) - { - *addr =3D unpack_pointer (value->type (), - value->contents ().data ()); - rc =3D 1; - } - } - catch (const gdb_exception &except) - { - gdbpy_convert_exception (except); - } - return rc; -} + /* The attribute was not present, or was present and its value was None. + No Python error has been set. */ + ATTR_MISSING, =20 -/* Get attribute from an object and convert it to the inferior's - pointer value. Return 1 if attribute exists and its value can be - converted. Otherwise, if attribute does not exist or its value is - None, return 0. In all other cases set Python error and return - 0. */ + /* The attribute was present, but there was some error while trying to + get the value from the attribute. A Python error will be set when + this is returned. */ + ATTR_ERROR, +}; =20 -static int +/* Get the attribute named ATTR_NAME from the object PYO and convert it to + an inferior pointer value, placing the pointer in *ADDR. + + Return pyuw_get_attr_code::ATTR_OK if the attribute was present and its + value was successfully written into *ADDR. For any other return value + the contents of *ADDR are undefined. + + Return pyuw_get_attr_code::ATTR_MISSING if the attribute was not + present, or it was present but its value was None. The contents of + *ADDR are undefined in this case. No Python error will be set in this + case. + + Return pyuw_get_attr_code::ATTR_ERROR if the attribute was present, but + there was some error while extracting the attribute's value. A Python + error will be set in this case. The contents of *ADDR are undefined. = */ + +static pyuw_get_attr_code pyuw_object_attribute_to_pointer (PyObject *pyo, const char *attr_name, CORE_ADDR *addr) { - int rc =3D 0; + if (!PyObject_HasAttrString (pyo, attr_name)) + return pyuw_get_attr_code::ATTR_MISSING; =20 - if (PyObject_HasAttrString (pyo, attr_name)) + gdbpy_ref<> pyo_value (PyObject_GetAttrString (pyo, attr_name)); + if (pyo_value =3D=3D nullptr) { - gdbpy_ref<> pyo_value (PyObject_GetAttrString (pyo, attr_name)); + gdb_assert (PyErr_Occurred ()); + return pyuw_get_attr_code::ATTR_ERROR; + } + if (pyo_value =3D=3D Py_None) + return pyuw_get_attr_code::ATTR_MISSING; =20 - if (pyo_value !=3D NULL && pyo_value !=3D Py_None) - { - rc =3D pyuw_value_obj_to_pointer (pyo_value.get (), addr); - if (!rc) - PyErr_Format ( - PyExc_ValueError, - _("The value of the '%s' attribute is not a pointer."), - attr_name); - } + if (get_addr_from_python (pyo_value.get (), addr) < 0) + { + gdb_assert (PyErr_Occurred ()); + return pyuw_get_attr_code::ATTR_ERROR; } - return rc; + + return pyuw_get_attr_code::ATTR_OK; } =20 /* Called by the Python interpreter to obtain string representation @@ -687,13 +692,18 @@ pending_framepy_create_unwind_info (PyObject *self, P= yObject *args) PENDING_FRAMEPY_REQUIRE_VALID ((pending_frame_object *) self); =20 if (!PyArg_ParseTuple (args, "O:create_unwind_info", &pyo_frame_id)) - return NULL; - if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "sp", &sp)) + return nullptr; + + pyuw_get_attr_code code + =3D pyuw_object_attribute_to_pointer (pyo_frame_id, "sp", &sp); + if (code =3D=3D pyuw_get_attr_code::ATTR_MISSING) { PyErr_SetString (PyExc_ValueError, _("frame_id should have 'sp' attribute.")); - return NULL; + return nullptr; } + else if (code =3D=3D pyuw_get_attr_code::ATTR_ERROR) + return nullptr; =20 /* The logic of building frame_id depending on the attributes of the frame_id object: @@ -704,13 +714,20 @@ pending_framepy_create_unwind_info (PyObject *self, P= yObject *args) Y Y N frame_id_build (sp, pc) Y Y Y frame_id_build_special (sp, pc, special) */ - if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "pc", &pc)) + code =3D pyuw_object_attribute_to_pointer (pyo_frame_id, "pc", &pc); + if (code =3D=3D pyuw_get_attr_code::ATTR_ERROR) + return nullptr; + else if (code =3D=3D pyuw_get_attr_code::ATTR_MISSING) return pyuw_create_unwind_info (self, frame_id_build_wild (sp)); - if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "special", &special= )) + + code =3D pyuw_object_attribute_to_pointer (pyo_frame_id, "special", &spe= cial); + if (code =3D=3D pyuw_get_attr_code::ATTR_ERROR) + return nullptr; + else if (code =3D=3D pyuw_get_attr_code::ATTR_MISSING) return pyuw_create_unwind_info (self, frame_id_build (sp, pc)); - else - return pyuw_create_unwind_info (self, - frame_id_build_special (sp, pc, special)); + + return pyuw_create_unwind_info (self, + frame_id_build_special (sp, pc, special)); } =20 /* Implementation of PendingFrame.architecture (self) -> gdb.Architecture.= */ diff --git a/gdb/testsuite/gdb.python/py-unwind.exp b/gdb/testsuite/gdb.pyt= hon/py-unwind.exp index d65b8447525..fddf4f15393 100644 --- a/gdb/testsuite/gdb.python/py-unwind.exp +++ b/gdb/testsuite/gdb.python/py-unwind.exp @@ -200,6 +200,42 @@ gdb_test "disable unwinder global \"simple\"" \ check_for_fixed_backtrace \ "check backtrace before testing PendingFrame methods" =20 +# Turn the 'simple' unwinder back on. +gdb_test "enable unwinder global \"simple\"" \ + "1 unwinder enabled" + +# Replace the "simple" unwinder with a new version that doesn't set +# the 'sp' attribute. Also the 'pc' attribute is invalid, but we'll +# hit the missing 'sp' error first. +with_test_prefix "frame-id 'sp' is None" { + gdb_test_no_output "python obj =3D simple_unwinder(\"simple\", None, \= "xyz\")" + gdb_test_no_output "python gdb.unwinder.register_unwinder(None, obj, r= eplace=3DTrue)" + gdb_test_no_output "python captured_pending_frame =3D None" + gdb_test "backtrace" \ + "Python Exception : frame_id should have 'sp' attribu= te\\.\r\n.*" +} + +# Replace the "simple" unwinder with a new version that sets the 'sp' +# attribute to an invalid value. Also the 'pc' attribute is invalid, but = we'll +# hit the invalid 'sp' error first. +with_test_prefix "frame-id 'sp' is invalid" { + gdb_test_no_output "python obj =3D simple_unwinder(\"simple\", \"jkl\"= , \"xyz\")" + gdb_test_no_output "python gdb.unwinder.register_unwinder(None, obj, r= eplace=3DTrue)" + gdb_test_no_output "python captured_pending_frame =3D None" + gdb_test "backtrace" \ + "Python Exception : invalid literal for int\\(\\) wit= h base 10: 'jkl'\r\n.*" +} + +# Replace the "simple" unwinder with a new version that sets the 'sp' +# to a valid value, but set the 'pc' attribute to an invalid value. +with_test_prefix "frame-id 'pc' is invalid" { + gdb_test_no_output "python obj =3D simple_unwinder(\"simple\", 0x123, = \"xyz\")" + gdb_test_no_output "python gdb.unwinder.register_unwinder(None, obj, r= eplace=3DTrue)" + gdb_test_no_output "python captured_pending_frame =3D None" + gdb_test "backtrace" \ + "Python Exception : invalid literal for int\\(\\) wit= h base 10: 'xyz'\r\n.*" +} + # Gather information about every frame. gdb_test_no_output "python capture_all_frame_information()" gdb_test_no_output "python gdb.newest_frame().select()" diff --git a/gdb/testsuite/gdb.python/py-unwind.py b/gdb/testsuite/gdb.pyth= on/py-unwind.py index f8f04b7f514..dbabb006e4b 100644 --- a/gdb/testsuite/gdb.python/py-unwind.py +++ b/gdb/testsuite/gdb.python/py-unwind.py @@ -141,8 +141,10 @@ captured_unwind_info_repr =3D None =20 =20 class simple_unwinder(Unwinder): - def __init__(self, name): + def __init__(self, name, sp=3D0x123, pc=3D0x456): super().__init__(name) + self._sp =3D sp + self._pc =3D pc =20 def __call__(self, pending_frame): global captured_pending_frame @@ -155,7 +157,7 @@ class simple_unwinder(Unwinder): if captured_pending_frame is None: captured_pending_frame =3D pending_frame captured_pending_frame_repr =3D repr(pending_frame) - fid =3D FrameId(gdb.Value(0x123), gdb.Value(0x456)) + fid =3D FrameId(self._sp, self._pc) uw =3D pending_frame.create_unwind_info(fid) uw.add_saved_register("rip", gdb.Value(0x123)) uw.add_saved_register("rbp", gdb.Value(0x456))