X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=gdb%2Fpython%2Fpy-frame.c;h=5c027547825a3ae0b385ee34efa37ca813825af9;hb=3666a04883754298b03884222206bfe756fbc520;hp=d78d80794bd70e73ac055cd37f52ab9842239087;hpb=08be3fe322244a3684d007d9282e225fc215f5d8;p=thirdparty%2Fbinutils-gdb.git diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c index d78d80794bd..5c027547825 100644 --- a/gdb/python/py-frame.c +++ b/gdb/python/py-frame.c @@ -1,6 +1,6 @@ /* Python interface to stack frames - Copyright (C) 2008-2014 Free Software Foundation, Inc. + Copyright (C) 2008-2021 Free Software Foundation, Inc. This file is part of GDB. @@ -27,9 +27,8 @@ #include "python-internal.h" #include "symfile.h" #include "objfiles.h" -#include "user-regs.h" -typedef struct { +struct frame_object { PyObject_HEAD struct frame_id frame_id; struct gdbarch *gdbarch; @@ -43,7 +42,7 @@ typedef struct { ID as the previous frame). Whenever get_prev_frame returns NULL, we record the frame_id of the next frame and set FRAME_ID_IS_NEXT to 1. */ int frame_id_is_next; -} frame_object; +}; /* Require a valid frame. This must be called inside a TRY_CATCH, or another context in which a gdb exception is allowed. */ @@ -80,17 +79,10 @@ frame_object_to_frame_info (PyObject *obj) static PyObject * frapy_str (PyObject *self) { - char *s; - PyObject *result; - struct ui_file *strfile; - - strfile = mem_fileopen (); - fprint_frame_id (strfile, ((frame_object *) self)->frame_id); - s = ui_file_xstrdup (strfile, NULL); - result = PyString_FromString (s); - xfree (s); + string_file strfile; - return result; + fprint_frame_id (&strfile, ((frame_object *) self)->frame_id); + return PyString_FromString (strfile.c_str ()); } /* Implementation of gdb.Frame.is_valid (self) -> Boolean. @@ -101,13 +93,15 @@ static PyObject * frapy_is_valid (PyObject *self, PyObject *args) { struct frame_info *frame = NULL; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { frame = frame_object_to_frame_info (self); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } if (frame == NULL) Py_RETURN_FALSE; @@ -122,27 +116,25 @@ static PyObject * frapy_name (PyObject *self, PyObject *args) { struct frame_info *frame; - char *name = NULL; + gdb::unique_xmalloc_ptr name; enum language lang; PyObject *result; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); - find_frame_funname (frame, &name, &lang, NULL); + name = find_frame_funname (frame, &lang, NULL); + } + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); } - - if (except.reason < 0) - xfree (name); - - GDB_PY_HANDLE_EXCEPTION (except); if (name) { - result = PyUnicode_Decode (name, strlen (name), host_charset (), NULL); - xfree (name); + result = PyUnicode_Decode (name.get (), strlen (name.get ()), + host_charset (), NULL); } else { @@ -161,17 +153,19 @@ frapy_type (PyObject *self, PyObject *args) { struct frame_info *frame; enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning. */ - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); type = get_frame_type (frame); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } - return PyInt_FromLong (type); + return gdb_py_object_from_longest (type).release (); } /* Implementation of gdb.Frame.architecture (self) -> gdb.Architecture. @@ -182,13 +176,15 @@ frapy_arch (PyObject *self, PyObject *args) { struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */ frame_object *obj = (frame_object *) self; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } return gdbarch_to_arch_object (obj->gdbarch); } @@ -200,18 +196,20 @@ static PyObject * frapy_unwind_stop_reason (PyObject *self, PyObject *args) { struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */ - volatile struct gdb_exception except; enum unwind_stop_reason stop_reason; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } stop_reason = get_frame_unwind_stop_reason (frame); - return PyInt_FromLong (stop_reason); + return gdb_py_object_from_longest (stop_reason).release (); } /* Implementation of gdb.Frame.pc (self) -> Long. @@ -222,17 +220,19 @@ frapy_pc (PyObject *self, PyObject *args) { CORE_ADDR pc = 0; /* Initialize to appease gcc warning. */ struct frame_info *frame; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); pc = get_frame_pc (frame); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } - return gdb_py_long_from_ulongest (pc); + return gdb_py_object_from_ulongest (pc).release (); } /* Implementation of gdb.Frame.read_register (self, register) -> gdb.Value. @@ -241,30 +241,35 @@ frapy_pc (PyObject *self, PyObject *args) static PyObject * frapy_read_register (PyObject *self, PyObject *args) { - volatile struct gdb_exception except; - const char *regnum_str; + PyObject *pyo_reg_id; struct value *val = NULL; - if (!PyArg_ParseTuple (args, "s", ®num_str)) + if (!PyArg_UnpackTuple (args, "read_register", 1, 1, &pyo_reg_id)) return NULL; - - TRY_CATCH (except, RETURN_MASK_ALL) + try { struct frame_info *frame; int regnum; FRAPY_REQUIRE_VALID (self, frame); - regnum = user_reg_map_name_to_regnum (get_frame_arch (frame), - regnum_str, - strlen (regnum_str)); - if (regnum >= 0) - val = value_of_register (regnum, frame); + if (!gdbpy_parse_register_id (get_frame_arch (frame), pyo_reg_id, + ®num)) + { + PyErr_SetString (PyExc_ValueError, "Bad register"); + return NULL; + } + + gdb_assert (regnum >= 0); + val = value_of_register (regnum, frame); if (val == NULL) - PyErr_SetString (PyExc_ValueError, _("Unknown register.")); + PyErr_SetString (PyExc_ValueError, _("Can't read register.")); + } + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); } - GDB_PY_HANDLE_EXCEPTION (except); return val == NULL ? NULL : value_to_value_object (val); } @@ -277,14 +282,16 @@ frapy_block (PyObject *self, PyObject *args) { struct frame_info *frame; const struct block *block = NULL, *fn_block; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); block = get_frame_block (frame, NULL); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } for (fn_block = block; fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL; @@ -316,15 +323,20 @@ frapy_function (PyObject *self, PyObject *args) { struct symbol *sym = NULL; struct frame_info *frame; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { + enum language funlang; + FRAPY_REQUIRE_VALID (self, frame); - sym = find_pc_function (get_frame_address_in_block (frame)); + gdb::unique_xmalloc_ptr funname + = find_frame_funname (frame, &funlang, &sym); + } + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); } - GDB_PY_HANDLE_EXCEPTION (except); if (sym) return symbol_to_symbol_object (sym); @@ -338,14 +350,12 @@ frapy_function (PyObject *self, PyObject *args) PyObject * frame_info_to_frame_object (struct frame_info *frame) { - frame_object *frame_obj; - volatile struct gdb_exception except; - - frame_obj = PyObject_New (frame_object, &frame_object_type); + gdbpy_ref frame_obj (PyObject_New (frame_object, + &frame_object_type)); if (frame_obj == NULL) return NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + try { /* Try to get the previous frame, to determine if this is the last frame @@ -365,13 +375,13 @@ frame_info_to_frame_object (struct frame_info *frame) } frame_obj->gdbarch = get_frame_arch (frame); } - if (except.reason < 0) + catch (const gdb_exception &except) { - Py_DECREF (frame_obj); gdbpy_convert_exception (except); return NULL; } - return (PyObject *) frame_obj; + + return (PyObject *) frame_obj.release (); } /* Implementation of gdb.Frame.older (self) -> gdb.Frame. @@ -382,19 +392,21 @@ static PyObject * frapy_older (PyObject *self, PyObject *args) { struct frame_info *frame, *prev = NULL; - volatile struct gdb_exception except; PyObject *prev_obj = NULL; /* Initialize to appease gcc warning. */ - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); prev = get_prev_frame (frame); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } if (prev) - prev_obj = (PyObject *) frame_info_to_frame_object (prev); + prev_obj = frame_info_to_frame_object (prev); else { Py_INCREF (Py_None); @@ -412,19 +424,21 @@ static PyObject * frapy_newer (PyObject *self, PyObject *args) { struct frame_info *frame, *next = NULL; - volatile struct gdb_exception except; PyObject *next_obj = NULL; /* Initialize to appease gcc warning. */ - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); next = get_next_frame (frame); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } if (next) - next_obj = (PyObject *) frame_info_to_frame_object (next); + next_obj = frame_info_to_frame_object (next); else { Py_INCREF (Py_None); @@ -441,18 +455,19 @@ static PyObject * frapy_find_sal (PyObject *self, PyObject *args) { struct frame_info *frame; - struct symtab_and_line sal; - volatile struct gdb_exception except; PyObject *sal_obj = NULL; /* Initialize to appease gcc warning. */ - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); - find_frame_sal (frame, &sal); + symtab_and_line sal = find_frame_sal (frame); sal_obj = symtab_and_line_to_sal_object (sal); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } return sal_obj; } @@ -470,8 +485,8 @@ frapy_read_var (PyObject *self, PyObject *args) struct frame_info *frame; PyObject *sym_obj, *block_obj = NULL; struct symbol *var = NULL; /* gcc-4.3.2 false warning. */ + const struct block *block = NULL; struct value *val = NULL; - volatile struct gdb_exception except; if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj)) return NULL; @@ -480,15 +495,11 @@ frapy_read_var (PyObject *self, PyObject *args) var = symbol_object_to_symbol (sym_obj); else if (gdbpy_is_string (sym_obj)) { - char *var_name; - const struct block *block = NULL; - struct cleanup *cleanup; - volatile struct gdb_exception except; + gdb::unique_xmalloc_ptr + var_name (python_string_to_target_string (sym_obj)); - var_name = python_string_to_target_string (sym_obj); if (!var_name) return NULL; - cleanup = make_cleanup (xfree, var_name); if (block_obj) { @@ -497,22 +508,23 @@ frapy_read_var (PyObject *self, PyObject *args) { PyErr_SetString (PyExc_RuntimeError, _("Second argument must be block.")); - do_cleanups (cleanup); return NULL; } } - TRY_CATCH (except, RETURN_MASK_ALL) + try { + struct block_symbol lookup_sym; FRAPY_REQUIRE_VALID (self, frame); if (!block) block = get_frame_block (frame, NULL); - var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL); + lookup_sym = lookup_symbol (var_name.get (), block, VAR_DOMAIN, NULL); + var = lookup_sym.symbol; + block = lookup_sym.block; } - if (except.reason < 0) + catch (const gdb_exception &except) { - do_cleanups (cleanup); gdbpy_convert_exception (except); return NULL; } @@ -520,13 +532,10 @@ frapy_read_var (PyObject *self, PyObject *args) if (!var) { PyErr_Format (PyExc_ValueError, - _("Variable '%s' not found."), var_name); - do_cleanups (cleanup); + _("Variable '%s' not found."), var_name.get ()); return NULL; } - - do_cleanups (cleanup); } else { @@ -535,13 +544,16 @@ frapy_read_var (PyObject *self, PyObject *args) return NULL; } - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, frame); - val = read_var_value (var, frame); + val = read_var_value (var, block, frame); + } + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); } - GDB_PY_HANDLE_EXCEPTION (except); return value_to_value_object (val); } @@ -552,15 +564,17 @@ static PyObject * frapy_select (PyObject *self, PyObject *args) { struct frame_info *fi; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { FRAPY_REQUIRE_VALID (self, fi); select_frame (fi); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } Py_RETURN_NONE; } @@ -572,13 +586,15 @@ PyObject * gdbpy_newest_frame (PyObject *self, PyObject *args) { struct frame_info *frame = NULL; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { frame = get_current_frame (); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } return frame_info_to_frame_object (frame); } @@ -590,13 +606,15 @@ PyObject * gdbpy_selected_frame (PyObject *self, PyObject *args) { struct frame_info *frame = NULL; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ALL) + try { frame = get_selected_frame ("No frame is currently selected."); } - GDB_PY_HANDLE_EXCEPTION (except); + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } return frame_info_to_frame_object (frame); } @@ -620,7 +638,7 @@ gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args) return NULL; } - str = unwind_stop_reason_to_string (reason); + str = unwind_stop_reason_to_string ((enum unwind_stop_reason) reason); return PyUnicode_Decode (str, strlen (str), host_charset (), NULL); }