static char *
gdbpy_readline_wrapper (FILE *sys_stdin, FILE *sys_stdout,
char *prompt)
{
int n;
char *p = NULL, *p_start, *p_end, *q;
volatile struct gdb_exception except;
TRY_CATCH (except, RETURN_MASK_ALL)
p = command_line_input (prompt, 0, "python");
/* Detect user interrupt (Ctrl-C). */
if (except.reason == RETURN_QUIT)
return NULL;
/* Handle errors by raising Python exceptions. */
if (except.reason < 0)
{
/* The thread state is nulled during gdbpy_readline_wrapper,
with the original value saved in the following undocumented
variable (see Python's Parser/myreadline.c and
Modules/readline.c). */
PyEval_RestoreThread (_PyOS_ReadlineTState);
gdbpy_convert_exception (except);
PyEval_SaveThread ();
return NULL;
}
/* Detect EOF (Ctrl-D). */
if (p == NULL)
{
q = PyMem_Malloc (1);
if (q != NULL)
q[0] = '\0';
return q;
}
n = strlen (p);
/* Copy the line to Python and return. */
q = PyMem_Malloc (n + 2);
if (q != NULL)
{
strncpy (q, p, n);
q[n] = '\n';
q[n + 1] = '\0';
}
return q;
}
void
bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj)
{
struct finish_breakpoint_object *self_finishbp =
(struct finish_breakpoint_object *) bp_obj;
/* Can compute return_value only once. */
gdb_assert (!self_finishbp->return_value);
if (!self_finishbp->return_type)
return;
TRY
{
struct value *function =
value_object_to_value (self_finishbp->function_value);
struct type *value_type =
type_object_to_type (self_finishbp->return_type);
/* bpfinishpy_init cannot finish into DUMMY_FRAME (throws an error
in such case) so it is OK to always pass CTX_SAVER as NULL. */
struct value *ret = get_return_value (function, value_type, NULL);
if (ret)
{
self_finishbp->return_value = value_to_value_object (ret);
if (!self_finishbp->return_value)
gdbpy_print_stack ();
}
else
{
Py_INCREF (Py_None);
self_finishbp->return_value = Py_None;
}
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
gdbpy_print_stack ();
}
void
bpfinishpy_pre_stop_hook (struct breakpoint_object *bp_obj)
{
struct finish_breakpoint_object *self_finishbp =
(struct finish_breakpoint_object *) bp_obj;
volatile struct gdb_exception except;
/* Can compute return_value only once. */
gdb_assert (!self_finishbp->return_value);
if (!self_finishbp->return_type)
return;
TRY_CATCH (except, RETURN_MASK_ALL)
{
struct value *function =
value_object_to_value (self_finishbp->function_value);
struct type *value_type =
type_object_to_type (self_finishbp->return_type);
struct value *ret = get_return_value (function, value_type);
if (ret)
{
self_finishbp->return_value = value_to_value_object (ret);
if (!self_finishbp->return_value)
gdbpy_print_stack ();
}
else
{
Py_INCREF (Py_None);
self_finishbp->return_value = Py_None;
}
}
if (except.reason < 0)
{
gdbpy_convert_exception (except);
gdbpy_print_stack ();
}
}
static PyObject *
archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw)
{
static char *keywords[] = { "start_pc", "end_pc", "count", NULL };
CORE_ADDR start, end = 0;
CORE_ADDR pc;
gdb_py_ulongest start_temp;
long count = 0, i;
PyObject *end_obj = NULL, *count_obj = NULL;
struct gdbarch *gdbarch = NULL;
ARCHPY_REQUIRE_VALID (self, gdbarch);
if (!PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO", keywords,
&start_temp, &end_obj, &count_obj))
return NULL;
start = start_temp;
if (end_obj)
{
/* 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. */
if (PyLong_Check (end_obj))
end = PyLong_AsUnsignedLongLong (end_obj);
#if PY_MAJOR_VERSION == 2
else if (PyInt_Check (end_obj))
/* If the end_pc value is specified without a trailing 'L', end_obj will
be an integer and not a long integer. */
end = PyInt_AsLong (end_obj);
#endif
else
{
PyErr_SetString (PyExc_TypeError,
_("Argument 'end_pc' should be a (long) integer."));
return NULL;
}
if (end < start)
{
PyErr_SetString (PyExc_ValueError,
_("Argument 'end_pc' should be greater than or "
"equal to the argument 'start_pc'."));
return NULL;
}
}
if (count_obj)
{
count = PyInt_AsLong (count_obj);
if (PyErr_Occurred () || count < 0)
{
PyErr_SetString (PyExc_TypeError,
_("Argument 'count' should be an non-negative "
"integer."));
return NULL;
}
}
gdbpy_ref<> result_list (PyList_New (0));
if (result_list == NULL)
return NULL;
for (pc = start, i = 0;
/* All args are specified. */
(end_obj && count_obj && pc <= end && i < count)
/* end_pc is specified, but no count. */
|| (end_obj && count_obj == NULL && pc <= end)
/* end_pc is not specified, but a count is. */
|| (end_obj == NULL && count_obj && i < count)
/* Both end_pc and count are not specified. */
|| (end_obj == NULL && count_obj == NULL && pc == start);)
{
int insn_len = 0;
gdbpy_ref<> insn_dict (PyDict_New ());
if (insn_dict == NULL)
return NULL;
if (PyList_Append (result_list.get (), insn_dict.get ()))
return NULL; /* PyList_Append Sets the exception. */
string_file stb;
TRY
{
insn_len = gdb_print_insn (gdbarch, pc, &stb, NULL);
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
return NULL;
}
END_CATCH
if (PyDict_SetItemString (insn_dict.get (), "addr",
gdb_py_long_from_ulongest (pc))
|| PyDict_SetItemString (insn_dict.get (), "asm",
PyString_FromString (!stb.empty ()
? stb.c_str ()
: "<unknown>"))
|| PyDict_SetItemString (insn_dict.get (), "length",
PyInt_FromLong (insn_len)))
return NULL;
pc += insn_len;
i++;
}
static int
bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *keywords[] = { "frame", "internal", NULL };
struct finish_breakpoint_object *self_bpfinish =
(struct finish_breakpoint_object *) self;
PyObject *frame_obj = NULL;
int thread;
struct frame_info *frame = NULL; /* init for gcc -Wall */
struct frame_info *prev_frame = NULL;
struct frame_id frame_id;
PyObject *internal = NULL;
int internal_bp = 0;
CORE_ADDR pc;
struct symbol *function;
if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
&frame_obj, &internal))
return -1;
TRY
{
/* Default frame to newest frame if necessary. */
if (frame_obj == NULL)
frame = get_current_frame ();
else
frame = frame_object_to_frame_info (frame_obj);
if (frame == NULL)
{
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
else
{
prev_frame = get_prev_frame (frame);
if (prev_frame == 0)
{
PyErr_SetString (PyExc_ValueError,
_("\"FinishBreakpoint\" not "
"meaningful in the outermost "
"frame."));
}
else if (get_frame_type (prev_frame) == DUMMY_FRAME)
{
PyErr_SetString (PyExc_ValueError,
_("\"FinishBreakpoint\" cannot "
"be set on a dummy frame."));
}
else
{
frame_id = get_frame_id (prev_frame);
if (frame_id_eq (frame_id, null_frame_id))
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
}
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
return -1;
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
gdbpy_print_stack ();
}
static PyObject *
archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw)
{
static char *keywords[] = { "start_pc", "end_pc", "count", NULL };
CORE_ADDR start, end = 0;
CORE_ADDR pc;
gdb_py_ulongest start_temp;
long count = 0, i;
PyObject *result_list, *end_obj = NULL, *count_obj = NULL;
struct gdbarch *gdbarch = NULL;
ARCHPY_REQUIRE_VALID (self, gdbarch);
if (!PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO", keywords,
&start_temp, &end_obj, &count_obj))
return NULL;
start = start_temp;
if (end_obj)
{
if (PyLong_Check (end_obj))
end = PyLong_AsUnsignedLongLong (end_obj);
else if (PyInt_Check (end_obj))
/* If the end_pc value is specified without a trailing 'L', end_obj will
be an integer and not a long integer. */
end = PyInt_AsLong (end_obj);
else
{
Py_DECREF (end_obj);
Py_XDECREF (count_obj);
PyErr_SetString (PyExc_TypeError,
_("Argument 'end_pc' should be a (long) integer."));
return NULL;
}
if (end < start)
{
Py_DECREF (end_obj);
Py_XDECREF (count_obj);
PyErr_SetString (PyExc_ValueError,
_("Argument 'end_pc' should be greater than or "
"equal to the argument 'start_pc'."));
return NULL;
}
}
if (count_obj)
{
count = PyInt_AsLong (count_obj);
if (PyErr_Occurred () || count < 0)
{
Py_DECREF (count_obj);
Py_XDECREF (end_obj);
PyErr_SetString (PyExc_TypeError,
_("Argument 'count' should be an non-negative "
"integer."));
return NULL;
}
}
result_list = PyList_New (0);
if (result_list == NULL)
return NULL;
for (pc = start, i = 0;
/* All args are specified. */
(end_obj && count_obj && pc <= end && i < count)
/* end_pc is specified, but no count. */
|| (end_obj && count_obj == NULL && pc <= end)
/* end_pc is not specified, but a count is. */
|| (end_obj == NULL && count_obj && i < count)
/* Both end_pc and count are not specified. */
|| (end_obj == NULL && count_obj == NULL && pc == start);)
{
int insn_len = 0;
char *as = NULL;
struct ui_file *memfile = mem_fileopen ();
PyObject *insn_dict = PyDict_New ();
volatile struct gdb_exception except;
if (insn_dict == NULL)
{
Py_DECREF (result_list);
ui_file_delete (memfile);
return NULL;
}
if (PyList_Append (result_list, insn_dict))
{
Py_DECREF (result_list);
Py_DECREF (insn_dict);
ui_file_delete (memfile);
return NULL; /* PyList_Append Sets the exception. */
}
TRY_CATCH (except, RETURN_MASK_ALL)
{
insn_len = gdb_print_insn (gdbarch, pc, memfile, NULL);
}
if (except.reason < 0)
{
Py_DECREF (result_list);
ui_file_delete (memfile);
gdbpy_convert_exception (except);
return NULL;
}
as = ui_file_xstrdup (memfile, NULL);
if (PyDict_SetItemString (insn_dict, "addr",
gdb_py_long_from_ulongest (pc))
|| PyDict_SetItemString (insn_dict, "asm",
PyString_FromString (*as ? as : "<unknown>"))
|| PyDict_SetItemString (insn_dict, "length",
PyInt_FromLong (insn_len)))
{
Py_DECREF (result_list);
ui_file_delete (memfile);
xfree (as);
return NULL;
}
pc += insn_len;
i++;
ui_file_delete (memfile);
xfree (as);
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
return EXT_LANG_BT_ERROR;
}
