Beispiel #1
0
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 ();
    }
}
Beispiel #4
0
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 ();
   }
Beispiel #7
0
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);
    }
Beispiel #8
0
 CATCH (except, RETURN_MASK_ALL)
   {
     gdbpy_convert_exception (except);
     return EXT_LANG_BT_ERROR;
   }