X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fpython%2Fpy-frame.c;h=0eef6543f848c622e313b8319a173cc97036d226;hb=b5eba2d8c050b39943918057283470959a5d18c3;hp=120e147e656b33ed47b0db9c8bf3e4a0d0de7baf;hpb=3977b71f1dfd04b6ac2c14e1405ce251c31a38aa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c index 120e147e65..0eef6543f8 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-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -21,13 +21,13 @@ #include "charset.h" #include "block.h" #include "frame.h" -#include "exceptions.h" #include "symtab.h" #include "stack.h" #include "value.h" #include "python-internal.h" #include "symfile.h" #include "objfiles.h" +#include "user-regs.h" typedef struct { PyObject_HEAD @@ -80,17 +80,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 +94,16 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH if (frame == NULL) Py_RETURN_FALSE; @@ -122,27 +118,26 @@ 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); } - - if (except.reason < 0) - xfree (name); - - GDB_PY_HANDLE_EXCEPTION (except); + CATCH (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH 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,15 +156,18 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return PyInt_FromLong (type); } @@ -182,13 +180,16 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return gdbarch_to_arch_object (obj->gdbarch); } @@ -200,14 +201,17 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH stop_reason = get_frame_unwind_stop_reason (frame); @@ -222,19 +226,59 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return gdb_py_long_from_ulongest (pc); } +/* Implementation of gdb.Frame.read_register (self, register) -> gdb.Value. + Returns the value of a register in this frame. */ + +static PyObject * +frapy_read_register (PyObject *self, PyObject *args) +{ + const char *regnum_str; + struct value *val = NULL; + + if (!PyArg_ParseTuple (args, "s", ®num_str)) + return NULL; + + 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 (val == NULL) + PyErr_SetString (PyExc_ValueError, _("Unknown register.")); + } + CATCH (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH + + return val == NULL ? NULL : value_to_value_object (val); +} + /* Implementation of gdb.Frame.block (self) -> gdb.Block. Returns the frame's code block. */ @@ -243,14 +287,17 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH for (fn_block = block; fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL; @@ -266,10 +313,8 @@ frapy_block (PyObject *self, PyObject *args) if (block) { - struct symtab *symt; - - symt = SYMBOL_SYMTAB (BLOCK_FUNCTION (fn_block)); - return block_to_block_object (block, symt->objfile); + return block_to_block_object + (block, symbol_objfile (BLOCK_FUNCTION (fn_block))); } Py_RETURN_NONE; @@ -284,15 +329,21 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); } - GDB_PY_HANDLE_EXCEPTION (except); + END_CATCH if (sym) return symbol_to_symbol_object (sym); @@ -306,14 +357,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 @@ -333,13 +382,14 @@ frame_info_to_frame_object (struct frame_info *frame) } frame_obj->gdbarch = get_frame_arch (frame); } - if (except.reason < 0) + CATCH (except, RETURN_MASK_ALL) { - Py_DECREF (frame_obj); gdbpy_convert_exception (except); return NULL; } - return (PyObject *) frame_obj; + END_CATCH + + return (PyObject *) frame_obj.release (); } /* Implementation of gdb.Frame.older (self) -> gdb.Frame. @@ -350,19 +400,22 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH if (prev) - prev_obj = (PyObject *) frame_info_to_frame_object (prev); + prev_obj = frame_info_to_frame_object (prev); else { Py_INCREF (Py_None); @@ -380,19 +433,22 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH if (next) - next_obj = (PyObject *) frame_info_to_frame_object (next); + next_obj = frame_info_to_frame_object (next); else { Py_INCREF (Py_None); @@ -409,18 +465,20 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return sal_obj; } @@ -438,8 +496,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; @@ -448,15 +506,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) { @@ -465,36 +519,35 @@ 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 (except, RETURN_MASK_ALL) { - do_cleanups (cleanup); gdbpy_convert_exception (except); return NULL; } + END_CATCH 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 { @@ -503,13 +556,17 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); } - GDB_PY_HANDLE_EXCEPTION (except); + END_CATCH return value_to_value_object (val); } @@ -520,15 +577,18 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH Py_RETURN_NONE; } @@ -540,13 +600,16 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return frame_info_to_frame_object (frame); } @@ -558,13 +621,16 @@ 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 (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return frame_info_to_frame_object (frame); } @@ -588,7 +654,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); } @@ -674,6 +740,9 @@ Return the reason why it's not possible to find frames older than this." }, { "pc", frapy_pc, METH_NOARGS, "pc () -> Long.\n\ Return the frame's resume address." }, + { "read_register", frapy_read_register, METH_VARARGS, + "read_register (register_name) -> gdb.Value\n\ +Return the value of the register in the frame." }, { "block", frapy_block, METH_NOARGS, "block () -> gdb.Block.\n\ Return the frame's code block." },