GDB (xrefs)
python.c
Go to the documentation of this file.
1 /* General python/gdb code
2 
3  Copyright (C) 2008-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "command.h"
23 #include "ui-out.h"
24 #include "cli/cli-script.h"
25 #include "gdbcmd.h"
26 #include "progspace.h"
27 #include "objfiles.h"
28 #include "value.h"
29 #include "language.h"
30 #include "event-loop.h"
31 #include "serial.h"
32 #include "readline/tilde.h"
33 #include "python.h"
34 #include "extension-priv.h"
35 #include "cli/cli-utils.h"
36 #include <ctype.h>
37 
38 /* Declared constants and enum for python stack printing. */
39 static const char python_excp_none[] = "none";
40 static const char python_excp_full[] = "full";
41 static const char python_excp_message[] = "message";
42 
43 /* "set python print-stack" choices. */
44 static const char *const python_excp_enums[] =
45  {
49  NULL
50  };
51 
52 /* The exception printing variable. 'full' if we want to print the
53  error message and stack, 'none' if we want to print nothing, and
54  'message' if we only want to print the error message. 'message' is
55  the default. */
57 
58 #ifdef HAVE_PYTHON
59 /* Forward decls, these are defined later. */
60 extern const struct extension_language_script_ops python_extension_script_ops;
61 extern const struct extension_language_ops python_extension_ops;
62 #endif
63 
64 /* The main struct describing GDB's interface to the Python
65  extension language. */
66 const struct extension_language_defn extension_language_python =
67 {
69  "python",
70  "Python",
71 
72  ".py",
73  "-gdb.py",
74 
76 
77 #ifdef HAVE_PYTHON
79  &python_extension_ops
80 #else
81  NULL,
82  NULL
83 #endif
84 };
85 
86 #ifdef HAVE_PYTHON
87 
88 #include "cli/cli-decode.h"
89 #include "charset.h"
90 #include "top.h"
91 #include "solib.h"
92 #include "python-internal.h"
93 #include "linespec.h"
94 #include "source.h"
95 #include "version.h"
96 #include "target.h"
97 #include "gdbthread.h"
98 #include "interps.h"
99 #include "event-top.h"
100 
101 /* True if Python has been successfully initialized, false
102  otherwise. */
103 
105 
106 extern PyMethodDef python_GdbMethods[];
107 
108 #ifdef IS_PY3K
109 extern struct PyModuleDef python_GdbModuleDef;
110 #endif
111 
112 PyObject *gdb_module;
114 
115 /* Some string constants we may wish to use. */
119 PyObject *gdbpy_doc_cst;
121 PyObject *gdbpy_value_cst;
122 
123 /* The GdbError exception. */
125 
126 /* The `gdb.error' base class. */
127 PyObject *gdbpy_gdb_error;
128 
129 /* The `gdb.MemoryError' exception. */
131 
135 static void gdbpy_finish_initialization
136  (const struct extension_language_defn *);
137 static int gdbpy_initialized (const struct extension_language_defn *);
139  (const struct extension_language_defn *, struct command_line *cmd);
140 static void gdbpy_start_type_printers (const struct extension_language_defn *,
141  struct ext_lang_type_printers *);
143  (const struct extension_language_defn *,
144  const struct ext_lang_type_printers *, struct type *, char **);
145 static void gdbpy_free_type_printers (const struct extension_language_defn *,
146  struct ext_lang_type_printers *);
147 static void gdbpy_clear_quit_flag (const struct extension_language_defn *);
148 static void gdbpy_set_quit_flag (const struct extension_language_defn *);
149 static int gdbpy_check_quit_flag (const struct extension_language_defn *);
151  (const struct extension_language_defn *, const char *current_gdb_prompt);
152 
153 /* The interface between gdb proper and loading of python scripts. */
154 
155 const struct extension_language_script_ops python_extension_script_ops =
156 {
161 };
162 
163 /* The interface between gdb proper and python extensions. */
164 
165 const struct extension_language_ops python_extension_ops =
166 {
169 
171 
175 
177 
179 
181 
184 
188 
190 
197 };
198 
199 /* Architecture and language to be used in callbacks from
200  the Python interpreter. */
203 
204 /* Restore global language and architecture and Python GIL state
205  when leaving the Python interpreter. */
206 
208 {
210  PyGILState_STATE state;
211  struct gdbarch *gdbarch;
212  const struct language_defn *language;
214 };
215 
216 static void
218 {
219  struct python_env *env = (struct python_env *)p;
220 
221  /* Leftover Python error is forbidden by Python Exception Handling. */
222  if (PyErr_Occurred ())
223  {
224  /* This order is similar to the one calling error afterwards. */
226  warning (_("internal error: Unhandled Python exception"));
227  }
228 
229  PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
230 
231  PyGILState_Release (env->state);
232  python_gdbarch = env->gdbarch;
233  python_language = env->language;
234 
236 
237  xfree (env);
238 }
239 
240 /* Called before entering the Python interpreter to install the
241  current language and architecture to be used for Python values.
242  Also set the active extension language for GDB so that SIGINT's
243  are directed our way, and if necessary install the right SIGINT
244  handler. */
245 
246 struct cleanup *
248  const struct language_defn *language)
249 {
250  struct python_env *env = xmalloc (sizeof *env);
251 
252  /* We should not ever enter Python unless initialized. */
253  if (!gdb_python_initialized)
254  error (_("Python not initialized"));
255 
256  env->previous_active = set_active_ext_lang (&extension_language_python);
257 
258  env->state = PyGILState_Ensure ();
259  env->gdbarch = python_gdbarch;
260  env->language = python_language;
261 
262  python_gdbarch = gdbarch;
263  python_language = language;
264 
265  /* Save it and ensure ! PyErr_Occurred () afterwards. */
266  PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
267 
268  return make_cleanup (restore_python_env, env);
269 }
270 
271 /* Clear the quit flag. */
272 
273 static void
275 {
276  /* This clears the flag as a side effect. */
277  PyOS_InterruptOccurred ();
278 }
279 
280 /* Set the quit flag. */
281 
282 static void
284 {
285  PyErr_SetInterrupt ();
286 }
287 
288 /* Return true if the quit flag has been set, false otherwise. */
289 
290 static int
292 {
293  return PyOS_InterruptOccurred ();
294 }
295 
296 /* Evaluate a Python command like PyRun_SimpleString, but uses
297  Py_single_input which prints the result of expressions, and does
298  not automatically print the stack on errors. */
299 
300 static int
301 eval_python_command (const char *command)
302 {
303  PyObject *m, *d, *v;
304 
305  m = PyImport_AddModule ("__main__");
306  if (m == NULL)
307  return -1;
308 
309  d = PyModule_GetDict (m);
310  if (d == NULL)
311  return -1;
312  v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
313  if (v == NULL)
314  return -1;
315 
316  Py_DECREF (v);
317 #ifndef IS_PY3K
318  if (Py_FlushLine ())
319  PyErr_Clear ();
320 #endif
321 
322  return 0;
323 }
324 
325 /* Implementation of the gdb "python-interactive" command. */
326 
327 static void
328 python_interactive_command (char *arg, int from_tty)
329 {
330  struct cleanup *cleanup;
331  int err;
332 
334  interpreter_async = 0;
335 
336  arg = skip_spaces (arg);
337 
339 
340  if (arg && *arg)
341  {
342  int len = strlen (arg);
343  char *script = xmalloc (len + 2);
344 
345  strcpy (script, arg);
346  script[len] = '\n';
347  script[len + 1] = '\0';
348  err = eval_python_command (script);
349  xfree (script);
350  }
351  else
352  {
353  err = PyRun_InteractiveLoop (instream, "<stdin>");
354  dont_repeat ();
355  }
356 
357  if (err)
358  {
360  error (_("Error while executing Python code."));
361  }
362 
363  do_cleanups (cleanup);
364 }
365 
366 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
367  named FILENAME.
368 
369  On Windows hosts few users would build Python themselves (this is no
370  trivial task on this platform), and thus use binaries built by
371  someone else instead. There may happen situation where the Python
372  library and GDB are using two different versions of the C runtime
373  library. Python, being built with VC, would use one version of the
374  msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
375  A FILE * from one runtime does not necessarily operate correctly in
376  the other runtime.
377 
378  To work around this potential issue, we create on Windows hosts the
379  FILE object using Python routines, thus making sure that it is
380  compatible with the Python library. */
381 
382 static void
383 python_run_simple_file (FILE *file, const char *filename)
384 {
385 #ifndef _WIN32
386 
387  PyRun_SimpleFile (file, filename);
388 
389 #else /* _WIN32 */
390 
391  char *full_path;
392  PyObject *python_file;
393  struct cleanup *cleanup;
394 
395  /* Because we have a string for a filename, and are using Python to
396  open the file, we need to expand any tilde in the path first. */
397  full_path = tilde_expand (filename);
398  cleanup = make_cleanup (xfree, full_path);
399  python_file = PyFile_FromString (full_path, "r");
400  if (! python_file)
401  {
402  do_cleanups (cleanup);
404  error (_("Error while opening file: %s"), full_path);
405  }
406 
407  make_cleanup_py_decref (python_file);
408  PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
409  do_cleanups (cleanup);
410 
411 #endif /* _WIN32 */
412 }
413 
414 /* Given a command_line, return a command string suitable for passing
415  to Python. Lines in the string are separated by newlines. The
416  return value is allocated using xmalloc and the caller is
417  responsible for freeing it. */
418 
419 static char *
421 {
422  struct command_line *iter;
423  char *script = NULL;
424  int size = 0;
425  int here;
426 
427  for (iter = l; iter; iter = iter->next)
428  size += strlen (iter->line) + 1;
429 
430  script = xmalloc (size + 1);
431  here = 0;
432  for (iter = l; iter; iter = iter->next)
433  {
434  int len = strlen (iter->line);
435 
436  strcpy (&script[here], iter->line);
437  here += len;
438  script[here++] = '\n';
439  }
440  script[here] = '\0';
441  return script;
442 }
443 
444 /* Take a command line structure representing a 'python' command, and
445  evaluate its body using the Python interpreter. */
446 
447 static void
449  struct command_line *cmd)
450 {
451  int ret;
452  char *script;
453  struct cleanup *cleanup;
454 
455  if (cmd->body_count != 1)
456  error (_("Invalid \"python\" block structure."));
457 
459 
460  script = compute_python_string (cmd->body_list[0]);
461  ret = PyRun_SimpleString (script);
462  xfree (script);
463  if (ret)
464  error (_("Error while executing Python code."));
465 
466  do_cleanups (cleanup);
467 }
468 
469 /* Implementation of the gdb "python" command. */
470 
471 static void
472 python_command (char *arg, int from_tty)
473 {
474  struct cleanup *cleanup;
475 
477 
479  interpreter_async = 0;
480 
481  arg = skip_spaces (arg);
482  if (arg && *arg)
483  {
484  if (PyRun_SimpleString (arg))
485  error (_("Error while executing Python code."));
486  }
487  else
488  {
489  struct command_line *l = get_command_line (python_control, "");
490 
493  }
494 
495  do_cleanups (cleanup);
496 }
497 
498 
499 
500 /* Transform a gdb parameters's value into a Python value. May return
501  NULL (and set a Python exception) on error. Helper function for
502  get_parameter. */
503 PyObject *
505 {
506  switch (type)
507  {
508  case var_string:
509  case var_string_noescape:
511  case var_filename:
512  case var_enum:
513  {
514  char *str = * (char **) var;
515 
516  if (! str)
517  str = "";
518  return PyString_Decode (str, strlen (str), host_charset (), NULL);
519  }
520 
521  case var_boolean:
522  {
523  if (* (int *) var)
524  Py_RETURN_TRUE;
525  else
526  Py_RETURN_FALSE;
527  }
528 
529  case var_auto_boolean:
530  {
531  enum auto_boolean ab = * (enum auto_boolean *) var;
532 
533  if (ab == AUTO_BOOLEAN_TRUE)
534  Py_RETURN_TRUE;
535  else if (ab == AUTO_BOOLEAN_FALSE)
536  Py_RETURN_FALSE;
537  else
538  Py_RETURN_NONE;
539  }
540 
541  case var_integer:
542  if ((* (int *) var) == INT_MAX)
543  Py_RETURN_NONE;
544  /* Fall through. */
545  case var_zinteger:
546  return PyLong_FromLong (* (int *) var);
547 
548  case var_uinteger:
549  {
550  unsigned int val = * (unsigned int *) var;
551 
552  if (val == UINT_MAX)
553  Py_RETURN_NONE;
554  return PyLong_FromUnsignedLong (val);
555  }
556  }
557 
558  return PyErr_Format (PyExc_RuntimeError,
559  _("Programmer error: unhandled type."));
560 }
561 
562 /* A Python function which returns a gdb parameter's value as a Python
563  value. */
564 
565 PyObject *
566 gdbpy_parameter (PyObject *self, PyObject *args)
567 {
568  struct gdb_exception except = exception_none;
569  struct cmd_list_element *alias, *prefix, *cmd;
570  const char *arg;
571  char *newarg;
572  int found = -1;
573 
574  if (! PyArg_ParseTuple (args, "s", &arg))
575  return NULL;
576 
577  newarg = concat ("show ", arg, (char *) NULL);
578 
579  TRY
580  {
581  found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
582  }
583  CATCH (ex, RETURN_MASK_ALL)
584  {
585  except = ex;
586  }
587  END_CATCH
588 
589  xfree (newarg);
590  GDB_PY_HANDLE_EXCEPTION (except);
591  if (!found)
592  return PyErr_Format (PyExc_RuntimeError,
593  _("Could not find parameter `%s'."), arg);
594 
595  if (! cmd->var)
596  return PyErr_Format (PyExc_RuntimeError,
597  _("`%s' is not a parameter."), arg);
598  return gdbpy_parameter_value (cmd->var_type, cmd->var);
599 }
600 
601 /* Wrapper for target_charset. */
602 
603 static PyObject *
604 gdbpy_target_charset (PyObject *self, PyObject *args)
605 {
606  const char *cset = target_charset (python_gdbarch);
607 
608  return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
609 }
610 
611 /* Wrapper for target_wide_charset. */
612 
613 static PyObject *
614 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
615 {
616  const char *cset = target_wide_charset (python_gdbarch);
617 
618  return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
619 }
620 
621 /* A Python function which evaluates a string using the gdb CLI. */
622 
623 static PyObject *
624 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
625 {
626  const char *arg;
627  PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
628  int from_tty, to_string;
629  static char *keywords[] = {"command", "from_tty", "to_string", NULL };
630  char *result = NULL;
631 
632  if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
633  &PyBool_Type, &from_tty_obj,
634  &PyBool_Type, &to_string_obj))
635  return NULL;
636 
637  from_tty = 0;
638  if (from_tty_obj)
639  {
640  int cmp = PyObject_IsTrue (from_tty_obj);
641  if (cmp < 0)
642  return NULL;
643  from_tty = cmp;
644  }
645 
646  to_string = 0;
647  if (to_string_obj)
648  {
649  int cmp = PyObject_IsTrue (to_string_obj);
650  if (cmp < 0)
651  return NULL;
652  to_string = cmp;
653  }
654 
655  TRY
656  {
657  /* Copy the argument text in case the command modifies it. */
658  char *copy = xstrdup (arg);
659  struct cleanup *cleanup = make_cleanup (xfree, copy);
660 
662  interpreter_async = 0;
663 
665  if (to_string)
666  result = execute_command_to_string (copy, from_tty);
667  else
668  {
669  result = NULL;
670  execute_command (copy, from_tty);
671  }
672 
673  do_cleanups (cleanup);
674  }
675  CATCH (except, RETURN_MASK_ALL)
676  {
677  GDB_PY_HANDLE_EXCEPTION (except);
678  }
679  END_CATCH
680 
681  /* Do any commands attached to breakpoint we stopped at. */
683 
684  if (result)
685  {
686  PyObject *r = PyString_FromString (result);
687  xfree (result);
688  return r;
689  }
690  Py_RETURN_NONE;
691 }
692 
693 /* Implementation of gdb.solib_name (Long) -> String.
694  Returns the name of the shared library holding a given address, or None. */
695 
696 static PyObject *
697 gdbpy_solib_name (PyObject *self, PyObject *args)
698 {
699  char *soname;
700  PyObject *str_obj;
701  gdb_py_longest pc;
702 
703  if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
704  return NULL;
705 
707  if (soname)
708  str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
709  else
710  {
711  str_obj = Py_None;
712  Py_INCREF (Py_None);
713  }
714 
715  return str_obj;
716 }
717 
718 /* A Python function which is a wrapper for decode_line_1. */
719 
720 static PyObject *
721 gdbpy_decode_line (PyObject *self, PyObject *args)
722 {
723  struct gdb_exception except = exception_none;
724  struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
725  appease gcc. */
726  struct symtab_and_line sal;
727  const char *arg = NULL;
728  char *copy_to_free = NULL, *copy = NULL;
729  struct cleanup *cleanups;
730  PyObject *result = NULL;
731  PyObject *return_result = NULL;
732  PyObject *unparsed = NULL;
733 
734  if (! PyArg_ParseTuple (args, "|s", &arg))
735  return NULL;
736 
737  cleanups = make_cleanup (null_cleanup, NULL);
738 
739  sals.sals = NULL;
740 
741  TRY
742  {
743  if (arg)
744  {
745  copy = xstrdup (arg);
746  copy_to_free = copy;
747  sals = decode_line_1 (&copy, 0, 0, 0);
748  }
749  else
750  {
753  sals.sals = &sal;
754  sals.nelts = 1;
755  }
756  }
757  CATCH (ex, RETURN_MASK_ALL)
758  {
759  except = ex;
760  }
761  END_CATCH
762 
763  if (sals.sals != NULL && sals.sals != &sal)
764  {
765  make_cleanup (xfree, copy_to_free);
766  make_cleanup (xfree, sals.sals);
767  }
768 
769  if (except.reason < 0)
770  {
771  do_cleanups (cleanups);
772  /* We know this will always throw. */
773  gdbpy_convert_exception (except);
774  return NULL;
775  }
776 
777  if (sals.nelts)
778  {
779  int i;
780 
781  result = PyTuple_New (sals.nelts);
782  if (! result)
783  goto error;
784  for (i = 0; i < sals.nelts; ++i)
785  {
786  PyObject *obj;
787 
788  obj = symtab_and_line_to_sal_object (sals.sals[i]);
789  if (! obj)
790  {
791  Py_DECREF (result);
792  goto error;
793  }
794 
795  PyTuple_SetItem (result, i, obj);
796  }
797  }
798  else
799  {
800  result = Py_None;
801  Py_INCREF (Py_None);
802  }
803 
804  return_result = PyTuple_New (2);
805  if (! return_result)
806  {
807  Py_DECREF (result);
808  goto error;
809  }
810 
811  if (copy && strlen (copy) > 0)
812  {
813  unparsed = PyString_FromString (copy);
814  if (unparsed == NULL)
815  {
816  Py_DECREF (result);
817  Py_DECREF (return_result);
818  return_result = NULL;
819  goto error;
820  }
821  }
822  else
823  {
824  unparsed = Py_None;
825  Py_INCREF (Py_None);
826  }
827 
828  PyTuple_SetItem (return_result, 0, unparsed);
829  PyTuple_SetItem (return_result, 1, result);
830 
831  error:
832  do_cleanups (cleanups);
833 
834  return return_result;
835 }
836 
837 /* Parse a string and evaluate it as an expression. */
838 static PyObject *
839 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
840 {
841  const char *expr_str;
842  struct value *result = NULL;
843 
844  if (!PyArg_ParseTuple (args, "s", &expr_str))
845  return NULL;
846 
847  TRY
848  {
849  result = parse_and_eval (expr_str);
850  }
851  CATCH (except, RETURN_MASK_ALL)
852  {
853  GDB_PY_HANDLE_EXCEPTION (except);
854  }
855  END_CATCH
856 
857  return value_to_value_object (result);
858 }
859 
860 /* Implementation of gdb.find_pc_line function.
861  Returns the gdb.Symtab_and_line object corresponding to a PC value. */
862 
863 static PyObject *
864 gdbpy_find_pc_line (PyObject *self, PyObject *args)
865 {
866  gdb_py_ulongest pc_llu;
867  PyObject *result = NULL; /* init for gcc -Wall */
868 
869  if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
870  return NULL;
871 
872  TRY
873  {
874  struct symtab_and_line sal;
875  CORE_ADDR pc;
876 
877  pc = (CORE_ADDR) pc_llu;
878  sal = find_pc_line (pc, 0);
879  result = symtab_and_line_to_sal_object (sal);
880  }
881  CATCH (except, RETURN_MASK_ALL)
882  {
883  GDB_PY_HANDLE_EXCEPTION (except);
884  }
885  END_CATCH
886 
887  return result;
888 }
889 
890 /* Read a file as Python code.
891  This is the extension_language_script_ops.script_sourcer "method".
892  FILE is the file to load. FILENAME is name of the file FILE.
893  This does not throw any errors. If an exception occurs python will print
894  the traceback and clear the error indicator. */
895 
896 static void
898  FILE *file, const char *filename)
899 {
900  struct cleanup *cleanup;
901 
903  python_run_simple_file (file, filename);
904  do_cleanups (cleanup);
905 }
906 
907 
908 
909 /* Posting and handling events. */
910 
911 /* A single event. */
913 {
914  /* The Python event. This is just a callable object. */
915  PyObject *event;
916  /* The next event. */
917  struct gdbpy_event *next;
918 };
919 
920 /* All pending events. */
922 /* The final link of the event list. */
924 
925 /* We use a file handler, and not an async handler, so that we can
926  wake up the main thread even when it is blocked in poll(). */
927 static struct serial *gdbpy_event_fds[2];
928 
929 /* The file handler callback. This reads from the internal pipe, and
930  then processes the Python event queue. This will always be run in
931  the main gdb thread. */
932 
933 static void
934 gdbpy_run_events (struct serial *scb, void *context)
935 {
936  struct cleanup *cleanup;
937 
939 
940  /* Flush the fd. Do this before flushing the events list, so that
941  any new event post afterwards is sure to re-awake the event
942  loop. */
943  while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
944  ;
945 
946  while (gdbpy_event_list)
947  {
948  PyObject *call_result;
949 
950  /* Dispatching the event might push a new element onto the event
951  loop, so we update here "atomically enough". */
952  struct gdbpy_event *item = gdbpy_event_list;
953  gdbpy_event_list = gdbpy_event_list->next;
954  if (gdbpy_event_list == NULL)
955  gdbpy_event_list_end = &gdbpy_event_list;
956 
957  /* Ignore errors. */
958  call_result = PyObject_CallObject (item->event, NULL);
959  if (call_result == NULL)
960  PyErr_Clear ();
961 
962  Py_XDECREF (call_result);
963  Py_DECREF (item->event);
964  xfree (item);
965  }
966 
967  do_cleanups (cleanup);
968 }
969 
970 /* Submit an event to the gdb thread. */
971 static PyObject *
972 gdbpy_post_event (PyObject *self, PyObject *args)
973 {
974  struct gdbpy_event *event;
975  PyObject *func;
976  int wakeup;
977 
978  if (!PyArg_ParseTuple (args, "O", &func))
979  return NULL;
980 
981  if (!PyCallable_Check (func))
982  {
983  PyErr_SetString (PyExc_RuntimeError,
984  _("Posted event is not callable"));
985  return NULL;
986  }
987 
988  Py_INCREF (func);
989 
990  /* From here until the end of the function, we have the GIL, so we
991  can operate on our global data structures without worrying. */
992  wakeup = gdbpy_event_list == NULL;
993 
994  event = XNEW (struct gdbpy_event);
995  event->event = func;
996  event->next = NULL;
997  *gdbpy_event_list_end = event;
998  gdbpy_event_list_end = &event->next;
999 
1000  /* Wake up gdb when needed. */
1001  if (wakeup)
1002  {
1003  char c = 'q'; /* Anything. */
1004 
1005  if (serial_write (gdbpy_event_fds[1], &c, 1))
1006  return PyErr_SetFromErrno (PyExc_IOError);
1007  }
1008 
1009  Py_RETURN_NONE;
1010 }
1011 
1012 /* Initialize the Python event handler. */
1013 static int
1015 {
1016  if (serial_pipe (gdbpy_event_fds) == 0)
1017  {
1018  gdbpy_event_list_end = &gdbpy_event_list;
1019  serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
1020  }
1021 
1022  return 0;
1023 }
1024 
1025 
1026 
1027 /* This is the extension_language_ops.before_prompt "method". */
1028 
1029 static enum ext_lang_rc
1031  const char *current_gdb_prompt)
1032 {
1033  struct cleanup *cleanup;
1034  char *prompt = NULL;
1035 
1036  if (!gdb_python_initialized)
1037  return EXT_LANG_RC_NOP;
1038 
1040 
1041  if (gdb_python_module
1042  && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
1043  {
1044  PyObject *hook;
1045 
1046  hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
1047  if (hook == NULL)
1048  goto fail;
1049 
1050  make_cleanup_py_decref (hook);
1051 
1052  if (PyCallable_Check (hook))
1053  {
1054  PyObject *result;
1055  PyObject *current_prompt;
1056 
1057  current_prompt = PyString_FromString (current_gdb_prompt);
1058  if (current_prompt == NULL)
1059  goto fail;
1060 
1061  result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
1062 
1063  Py_DECREF (current_prompt);
1064 
1065  if (result == NULL)
1066  goto fail;
1067 
1068  make_cleanup_py_decref (result);
1069 
1070  /* Return type should be None, or a String. If it is None,
1071  fall through, we will not set a prompt. If it is a
1072  string, set PROMPT. Anything else, set an exception. */
1073  if (result != Py_None && ! PyString_Check (result))
1074  {
1075  PyErr_Format (PyExc_RuntimeError,
1076  _("Return from prompt_hook must " \
1077  "be either a Python string, or None"));
1078  goto fail;
1079  }
1080 
1081  if (result != Py_None)
1082  {
1083  prompt = python_string_to_host_string (result);
1084 
1085  if (prompt == NULL)
1086  goto fail;
1087  else
1088  make_cleanup (xfree, prompt);
1089  }
1090  }
1091  }
1092 
1093  /* If a prompt has been set, PROMPT will not be NULL. If it is
1094  NULL, do not set the prompt. */
1095  if (prompt != NULL)
1096  set_prompt (prompt);
1097 
1098  do_cleanups (cleanup);
1099  return prompt != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_NOP;
1100 
1101  fail:
1102  gdbpy_print_stack ();
1103  do_cleanups (cleanup);
1104  return EXT_LANG_RC_ERROR;
1105 }
1106 
1107 
1108 
1109 /* Printing. */
1110 
1111 /* A python function to write a single string using gdb's filtered
1112  output stream . The optional keyword STREAM can be used to write
1113  to a particular stream. The default stream is to gdb_stdout. */
1114 
1115 static PyObject *
1116 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
1117 {
1118  const char *arg;
1119  static char *keywords[] = {"text", "stream", NULL };
1120  int stream_type = 0;
1121 
1122  if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
1123  &stream_type))
1124  return NULL;
1125 
1126  TRY
1127  {
1128  switch (stream_type)
1129  {
1130  case 1:
1131  {
1132  fprintf_filtered (gdb_stderr, "%s", arg);
1133  break;
1134  }
1135  case 2:
1136  {
1137  fprintf_filtered (gdb_stdlog, "%s", arg);
1138  break;
1139  }
1140  default:
1141  fprintf_filtered (gdb_stdout, "%s", arg);
1142  }
1143  }
1144  CATCH (except, RETURN_MASK_ALL)
1145  {
1146  GDB_PY_HANDLE_EXCEPTION (except);
1147  }
1148  END_CATCH
1149 
1150  Py_RETURN_NONE;
1151 }
1152 
1153 /* A python function to flush a gdb stream. The optional keyword
1154  STREAM can be used to flush a particular stream. The default stream
1155  is gdb_stdout. */
1156 
1157 static PyObject *
1158 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
1159 {
1160  static char *keywords[] = {"stream", NULL };
1161  int stream_type = 0;
1162 
1163  if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
1164  &stream_type))
1165  return NULL;
1166 
1167  switch (stream_type)
1168  {
1169  case 1:
1170  {
1172  break;
1173  }
1174  case 2:
1175  {
1177  break;
1178  }
1179  default:
1181  }
1182 
1183  Py_RETURN_NONE;
1184 }
1185 
1186 /* Return non-zero if print-stack is not "none". */
1187 
1188 int
1190 {
1191  return gdbpy_should_print_stack != python_excp_none;
1192 }
1193 
1194 /* Print a python exception trace, print just a message, or print
1195  nothing and clear the python exception, depending on
1196  gdbpy_should_print_stack. Only call this if a python exception is
1197  set. */
1198 void
1200 {
1201 
1202  /* Print "none", just clear exception. */
1203  if (gdbpy_should_print_stack == python_excp_none)
1204  {
1205  PyErr_Clear ();
1206  }
1207  /* Print "full" message and backtrace. */
1208  else if (gdbpy_should_print_stack == python_excp_full)
1209  {
1210  PyErr_Print ();
1211  /* PyErr_Print doesn't necessarily end output with a newline.
1212  This works because Python's stdout/stderr is fed through
1213  printf_filtered. */
1214  TRY
1215  {
1216  begin_line ();
1217  }
1218  CATCH (except, RETURN_MASK_ALL)
1219  {
1220  }
1221  END_CATCH
1222  }
1223  /* Print "message", just error print message. */
1224  else
1225  {
1226  PyObject *ptype, *pvalue, *ptraceback;
1227  char *msg = NULL, *type = NULL;
1228 
1229  PyErr_Fetch (&ptype, &pvalue, &ptraceback);
1230 
1231  /* Fetch the error message contained within ptype, pvalue. */
1232  msg = gdbpy_exception_to_string (ptype, pvalue);
1233  type = gdbpy_obj_to_string (ptype);
1234 
1235  TRY
1236  {
1237  if (msg == NULL)
1238  {
1239  /* An error occurred computing the string representation of the
1240  error message. */
1242  _("Error occurred computing Python error" \
1243  "message.\n"));
1244  }
1245  else
1246  fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
1247  type, msg);
1248  }
1249  CATCH (except, RETURN_MASK_ALL)
1250  {
1251  }
1252  END_CATCH
1253 
1254  Py_XDECREF (ptype);
1255  Py_XDECREF (pvalue);
1256  Py_XDECREF (ptraceback);
1257  xfree (msg);
1258  }
1259 }
1260 
1261 
1262 
1263 /* Return the current Progspace.
1264  There always is one. */
1265 
1266 static PyObject *
1267 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
1268 {
1269  PyObject *result;
1270 
1272  if (result)
1273  Py_INCREF (result);
1274  return result;
1275 }
1276 
1277 /* Return a sequence holding all the Progspaces. */
1278 
1279 static PyObject *
1280 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
1281 {
1282  struct program_space *ps;
1283  PyObject *list;
1284 
1285  list = PyList_New (0);
1286  if (!list)
1287  return NULL;
1288 
1289  ALL_PSPACES (ps)
1290  {
1291  PyObject *item = pspace_to_pspace_object (ps);
1292 
1293  if (!item || PyList_Append (list, item) == -1)
1294  {
1295  Py_DECREF (list);
1296  return NULL;
1297  }
1298  }
1299 
1300  return list;
1301 }
1302 
1303 
1304 
1305 /* The "current" objfile. This is set when gdb detects that a new
1306  objfile has been loaded. It is only set for the duration of a call to
1307  gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1308  at other times. */
1310 
1311 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1312  as Python code. This does not throw any errors. If an exception
1313  occurs python will print the traceback and clear the error indicator.
1314  This is the extension_language_script_ops.objfile_script_sourcer
1315  "method". */
1316 
1317 static void
1319  struct objfile *objfile, FILE *file,
1320  const char *filename)
1321 {
1322  struct cleanup *cleanups;
1323 
1324  if (!gdb_python_initialized)
1325  return;
1326 
1327  cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1328  gdbpy_current_objfile = objfile;
1329 
1330  python_run_simple_file (file, filename);
1331 
1332  do_cleanups (cleanups);
1333  gdbpy_current_objfile = NULL;
1334 }
1335 
1336 /* Set the current objfile to OBJFILE and then execute SCRIPT
1337  as Python code. This does not throw any errors. If an exception
1338  occurs python will print the traceback and clear the error indicator.
1339  This is the extension_language_script_ops.objfile_script_executor
1340  "method". */
1341 
1342 static void
1344  struct objfile *objfile, const char *name,
1345  const char *script)
1346 {
1347  struct cleanup *cleanups;
1348 
1349  if (!gdb_python_initialized)
1350  return;
1351 
1352  cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1353  gdbpy_current_objfile = objfile;
1354 
1355  PyRun_SimpleString (script);
1356 
1357  do_cleanups (cleanups);
1358  gdbpy_current_objfile = NULL;
1359 }
1360 
1361 /* Return the current Objfile, or None if there isn't one. */
1362 
1363 static PyObject *
1364 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1365 {
1366  PyObject *result;
1367 
1368  if (! gdbpy_current_objfile)
1369  Py_RETURN_NONE;
1370 
1371  result = objfile_to_objfile_object (gdbpy_current_objfile);
1372  if (result)
1373  Py_INCREF (result);
1374  return result;
1375 }
1376 
1377 /* Return a sequence holding all the Objfiles. */
1378 
1379 static PyObject *
1380 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1381 {
1382  struct objfile *objf;
1383  PyObject *list;
1384 
1385  list = PyList_New (0);
1386  if (!list)
1387  return NULL;
1388 
1389  ALL_OBJFILES (objf)
1390  {
1391  PyObject *item = objfile_to_objfile_object (objf);
1392 
1393  if (!item || PyList_Append (list, item) == -1)
1394  {
1395  Py_DECREF (list);
1396  return NULL;
1397  }
1398  }
1399 
1400  return list;
1401 }
1402 
1403 /* Compute the list of active python type printers and store them in
1404  EXT_PRINTERS->py_type_printers. The product of this function is used by
1405  gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1406  This is the extension_language_ops.start_type_printers "method". */
1407 
1408 static void
1410  struct ext_lang_type_printers *ext_printers)
1411 {
1412  struct cleanup *cleanups;
1413  PyObject *type_module, *func = NULL, *printers_obj = NULL;
1414 
1415  if (!gdb_python_initialized)
1416  return;
1417 
1419 
1420  type_module = PyImport_ImportModule ("gdb.types");
1421  if (type_module == NULL)
1422  {
1423  gdbpy_print_stack ();
1424  goto done;
1425  }
1426 
1427  func = PyObject_GetAttrString (type_module, "get_type_recognizers");
1428  if (func == NULL)
1429  {
1430  gdbpy_print_stack ();
1431  goto done;
1432  }
1433 
1434  printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
1435  if (printers_obj == NULL)
1436  gdbpy_print_stack ();
1437  else
1438  ext_printers->py_type_printers = printers_obj;
1439 
1440  done:
1441  Py_XDECREF (type_module);
1442  Py_XDECREF (func);
1443  do_cleanups (cleanups);
1444 }
1445 
1446 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1447  a newly allocated string holding the type's replacement name, and return
1448  EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1449  If there's a Python error return EXT_LANG_RC_ERROR.
1450  Otherwise, return EXT_LANG_RC_NOP.
1451  This is the extension_language_ops.apply_type_printers "method". */
1452 
1453 static enum ext_lang_rc
1455  const struct ext_lang_type_printers *ext_printers,
1456  struct type *type, char **prettied_type)
1457 {
1458  struct cleanup *cleanups;
1459  PyObject *type_obj, *type_module = NULL, *func = NULL;
1460  PyObject *result_obj = NULL;
1461  PyObject *printers_obj = ext_printers->py_type_printers;
1462  char *result = NULL;
1463 
1464  if (printers_obj == NULL)
1465  return EXT_LANG_RC_NOP;
1466 
1467  if (!gdb_python_initialized)
1468  return EXT_LANG_RC_NOP;
1469 
1471 
1472  type_obj = type_to_type_object (type);
1473  if (type_obj == NULL)
1474  {
1475  gdbpy_print_stack ();
1476  goto done;
1477  }
1478 
1479  type_module = PyImport_ImportModule ("gdb.types");
1480  if (type_module == NULL)
1481  {
1482  gdbpy_print_stack ();
1483  goto done;
1484  }
1485 
1486  func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
1487  if (func == NULL)
1488  {
1489  gdbpy_print_stack ();
1490  goto done;
1491  }
1492 
1493  result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
1494  type_obj, (char *) NULL);
1495  if (result_obj == NULL)
1496  {
1497  gdbpy_print_stack ();
1498  goto done;
1499  }
1500 
1501  if (result_obj != Py_None)
1502  {
1503  result = python_string_to_host_string (result_obj);
1504  if (result == NULL)
1505  gdbpy_print_stack ();
1506  }
1507 
1508  done:
1509  Py_XDECREF (type_obj);
1510  Py_XDECREF (type_module);
1511  Py_XDECREF (func);
1512  Py_XDECREF (result_obj);
1513  do_cleanups (cleanups);
1514  if (result != NULL)
1515  *prettied_type = result;
1516  return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR;
1517 }
1518 
1519 /* Free the result of start_type_printers.
1520  This is the extension_language_ops.free_type_printers "method". */
1521 
1522 static void
1524  struct ext_lang_type_printers *ext_printers)
1525 {
1526  struct cleanup *cleanups;
1527  PyObject *printers = ext_printers->py_type_printers;
1528 
1529  if (printers == NULL)
1530  return;
1531 
1532  if (!gdb_python_initialized)
1533  return;
1534 
1536  Py_DECREF (printers);
1537  do_cleanups (cleanups);
1538 }
1539 
1540 #else /* HAVE_PYTHON */
1541 
1542 /* Dummy implementation of the gdb "python-interactive" and "python"
1543  command. */
1544 
1545 static void
1546 python_interactive_command (char *arg, int from_tty)
1547 {
1548  arg = skip_spaces (arg);
1549  if (arg && *arg)
1550  error (_("Python scripting is not supported in this copy of GDB."));
1551  else
1552  {
1553  struct command_line *l = get_command_line (python_control, "");
1554  struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
1555 
1557  do_cleanups (cleanups);
1558  }
1559 }
1560 
1561 static void
1562 python_command (char *arg, int from_tty)
1563 {
1564  python_interactive_command (arg, from_tty);
1565 }
1566 
1567 #endif /* HAVE_PYTHON */
1568 
1569 
1570 
1571 /* Lists for 'set python' commands. */
1572 
1575 
1576 /* Function for use by 'set python' prefix command. */
1577 
1578 static void
1579 user_set_python (char *args, int from_tty)
1580 {
1581  help_list (user_set_python_list, "set python ", all_commands,
1582  gdb_stdout);
1583 }
1584 
1585 /* Function for use by 'show python' prefix command. */
1586 
1587 static void
1588 user_show_python (char *args, int from_tty)
1589 {
1590  cmd_show_list (user_show_python_list, from_tty, "");
1591 }
1592 
1593 /* Initialize the Python code. */
1594 
1595 #ifdef HAVE_PYTHON
1596 
1597 /* This is installed as a final cleanup and cleans up the
1598  interpreter. This lets Python's 'atexit' work. */
1599 
1600 static void
1602 {
1603  struct active_ext_lang_state *previous_active;
1604 
1605  /* We don't use ensure_python_env here because if we ever ran the
1606  cleanup, gdb would crash -- because the cleanup calls into the
1607  Python interpreter, which we are about to destroy. It seems
1608  clearer to make the needed calls explicitly here than to create a
1609  cleanup and then mysteriously discard it. */
1610 
1611  /* This is only called as a final cleanup so we can assume the active
1612  SIGINT handler is gdb's. We still need to tell it to notify Python. */
1613  previous_active = set_active_ext_lang (&extension_language_python);
1614 
1615  (void) PyGILState_Ensure ();
1616  python_gdbarch = target_gdbarch ();
1617  python_language = current_language;
1618 
1619  Py_Finalize ();
1620 
1621  restore_active_ext_lang (previous_active);
1622 }
1623 #endif
1624 
1625 /* Provide a prototype to silence -Wmissing-prototypes. */
1627 
1628 void
1630 {
1631  char *progname;
1632 #ifdef IS_PY3K
1633  int i;
1634  size_t progsize, count;
1635  char *oldloc;
1636  wchar_t *progname_copy;
1637 #endif
1638 
1639  add_com ("python-interactive", class_obscure,
1641 #ifdef HAVE_PYTHON
1642  _("\
1643 Start an interactive Python prompt.\n\
1644 \n\
1645 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1646 prompt).\n\
1647 \n\
1648 Alternatively, a single-line Python command can be given as an\n\
1649 argument, and if the command is an expression, the result will be\n\
1650 printed. For example:\n\
1651 \n\
1652  (gdb) python-interactive 2 + 3\n\
1653  5\n\
1654 ")
1655 #else /* HAVE_PYTHON */
1656  _("\
1657 Start a Python interactive prompt.\n\
1658 \n\
1659 Python scripting is not supported in this copy of GDB.\n\
1660 This command is only a placeholder.")
1661 #endif /* HAVE_PYTHON */
1662  );
1663  add_com_alias ("pi", "python-interactive", class_obscure, 1);
1664 
1665  add_com ("python", class_obscure, python_command,
1666 #ifdef HAVE_PYTHON
1667  _("\
1668 Evaluate a Python command.\n\
1669 \n\
1670 The command can be given as an argument, for instance:\n\
1671 \n\
1672  python print 23\n\
1673 \n\
1674 If no argument is given, the following lines are read and used\n\
1675 as the Python commands. Type a line containing \"end\" to indicate\n\
1676 the end of the command.")
1677 #else /* HAVE_PYTHON */
1678  _("\
1679 Evaluate a Python command.\n\
1680 \n\
1681 Python scripting is not supported in this copy of GDB.\n\
1682 This command is only a placeholder.")
1683 #endif /* HAVE_PYTHON */
1684  );
1685  add_com_alias ("py", "python", class_obscure, 1);
1686 
1687  /* Add set/show python print-stack. */
1689  _("Prefix command for python preference settings."),
1690  &user_show_python_list, "show python ", 0,
1691  &showlist);
1692 
1694  _("Prefix command for python preference settings."),
1695  &user_set_python_list, "set python ", 0,
1696  &setlist);
1697 
1698  add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1699  &gdbpy_should_print_stack, _("\
1700 Set mode for Python stack dump on error."), _("\
1701 Show the mode of Python stack printing on error."), _("\
1702 none == no stack or message will be printed.\n\
1703 full == a message and a stack will be printed.\n\
1704 message == an error message without a stack will be printed."),
1705  NULL, NULL,
1706  &user_set_python_list,
1707  &user_show_python_list);
1708 
1709 #ifdef HAVE_PYTHON
1710 #ifdef WITH_PYTHON_PATH
1711  /* Work around problem where python gets confused about where it is,
1712  and then can't find its libraries, etc.
1713  NOTE: Python assumes the following layout:
1714  /foo/bin/python
1715  /foo/lib/pythonX.Y/...
1716  This must be done before calling Py_Initialize. */
1717  progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
1718  SLASH_STRING, "python", NULL);
1719 #ifdef IS_PY3K
1720  oldloc = setlocale (LC_ALL, NULL);
1721  setlocale (LC_ALL, "");
1722  progsize = strlen (progname);
1723  if (progsize == (size_t) -1)
1724  {
1725  fprintf (stderr, "Could not convert python path to string\n");
1726  return;
1727  }
1728  progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
1729  if (!progname_copy)
1730  {
1731  fprintf (stderr, "out of memory\n");
1732  return;
1733  }
1734  count = mbstowcs (progname_copy, progname, progsize + 1);
1735  if (count == (size_t) -1)
1736  {
1737  fprintf (stderr, "Could not convert python path to string\n");
1738  return;
1739  }
1740  setlocale (LC_ALL, oldloc);
1741 
1742  /* Note that Py_SetProgramName expects the string it is passed to
1743  remain alive for the duration of the program's execution, so
1744  it is not freed after this call. */
1745  Py_SetProgramName (progname_copy);
1746 #else
1747  Py_SetProgramName (progname);
1748 #endif
1749 #endif
1750 
1751  Py_Initialize ();
1752  PyEval_InitThreads ();
1753 
1754 #ifdef IS_PY3K
1755  gdb_module = PyModule_Create (&python_GdbModuleDef);
1756  /* Add _gdb module to the list of known built-in modules. */
1757  _PyImport_FixupBuiltin (gdb_module, "_gdb");
1758 #else
1759  gdb_module = Py_InitModule ("_gdb", python_GdbMethods);
1760 #endif
1761  if (gdb_module == NULL)
1762  goto fail;
1763 
1764  /* The casts to (char*) are for python 2.4. */
1765  if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
1766  || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
1767  (char*) host_name) < 0
1768  || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1769  (char*) target_name) < 0)
1770  goto fail;
1771 
1772  /* Add stream constants. */
1773  if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
1774  || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
1775  || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
1776  goto fail;
1777 
1778  gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1779  if (gdbpy_gdb_error == NULL
1780  || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
1781  goto fail;
1782 
1783  gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1784  gdbpy_gdb_error, NULL);
1785  if (gdbpy_gdb_memory_error == NULL
1786  || gdb_pymodule_addobject (gdb_module, "MemoryError",
1787  gdbpy_gdb_memory_error) < 0)
1788  goto fail;
1789 
1790  gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1791  if (gdbpy_gdberror_exc == NULL
1792  || gdb_pymodule_addobject (gdb_module, "GdbError",
1793  gdbpy_gdberror_exc) < 0)
1794  goto fail;
1795 
1797 
1798  if (gdbpy_initialize_auto_load () < 0
1799  || gdbpy_initialize_values () < 0
1800  || gdbpy_initialize_frames () < 0
1801  || gdbpy_initialize_commands () < 0
1802  || gdbpy_initialize_symbols () < 0
1803  || gdbpy_initialize_symtabs () < 0
1804  || gdbpy_initialize_blocks () < 0
1805  || gdbpy_initialize_functions () < 0
1806  || gdbpy_initialize_parameters () < 0
1807  || gdbpy_initialize_types () < 0
1808  || gdbpy_initialize_pspace () < 0
1809  || gdbpy_initialize_objfile () < 0
1813  || gdbpy_initialize_linetable () < 0
1814  || gdbpy_initialize_thread () < 0
1815  || gdbpy_initialize_inferior () < 0
1816  || gdbpy_initialize_events () < 0
1818  || gdbpy_initialize_py_events () < 0
1819  || gdbpy_initialize_event () < 0
1820  || gdbpy_initialize_stop_event () < 0
1832  || gdbpy_initialize_arch () < 0
1833  || gdbpy_initialize_xmethods () < 0
1834  || gdbpy_initialize_unwind () < 0)
1835  goto fail;
1836 
1837  gdbpy_to_string_cst = PyString_FromString ("to_string");
1838  if (gdbpy_to_string_cst == NULL)
1839  goto fail;
1840  gdbpy_children_cst = PyString_FromString ("children");
1841  if (gdbpy_children_cst == NULL)
1842  goto fail;
1843  gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1844  if (gdbpy_display_hint_cst == NULL)
1845  goto fail;
1846  gdbpy_doc_cst = PyString_FromString ("__doc__");
1847  if (gdbpy_doc_cst == NULL)
1848  goto fail;
1849  gdbpy_enabled_cst = PyString_FromString ("enabled");
1850  if (gdbpy_enabled_cst == NULL)
1851  goto fail;
1852  gdbpy_value_cst = PyString_FromString ("value");
1853  if (gdbpy_value_cst == NULL)
1854  goto fail;
1855 
1856  /* Release the GIL while gdb runs. */
1857  PyThreadState_Swap (NULL);
1858  PyEval_ReleaseLock ();
1859 
1861 
1862  gdb_python_initialized = 1;
1863  return;
1864 
1865  fail:
1866  gdbpy_print_stack ();
1867  /* Do not set 'gdb_python_initialized'. */
1868  return;
1869 
1870 #endif /* HAVE_PYTHON */
1871 }
1872 
1873 #ifdef HAVE_PYTHON
1874 
1875 /* Perform the remaining python initializations.
1876  These must be done after GDB is at least mostly initialized.
1877  E.g., The "info pretty-printer" command needs the "info" prefix
1878  command installed.
1879  This is the extension_language_ops.finish_initialization "method". */
1880 
1881 static void
1883 {
1884  PyObject *m;
1885  char *gdb_pythondir;
1886  PyObject *sys_path;
1887  struct cleanup *cleanup;
1888 
1890 
1891  /* Add the initial data-directory to sys.path. */
1892 
1893  gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1894  make_cleanup (xfree, gdb_pythondir);
1895 
1896  sys_path = PySys_GetObject ("path");
1897 
1898  /* If sys.path is not defined yet, define it first. */
1899  if (!(sys_path && PyList_Check (sys_path)))
1900  {
1901 #ifdef IS_PY3K
1902  PySys_SetPath (L"");
1903 #else
1904  PySys_SetPath ("");
1905 #endif
1906  sys_path = PySys_GetObject ("path");
1907  }
1908  if (sys_path && PyList_Check (sys_path))
1909  {
1910  PyObject *pythondir;
1911  int err;
1912 
1913  pythondir = PyString_FromString (gdb_pythondir);
1914  if (pythondir == NULL)
1915  goto fail;
1916 
1917  err = PyList_Insert (sys_path, 0, pythondir);
1918  Py_DECREF (pythondir);
1919  if (err)
1920  goto fail;
1921  }
1922  else
1923  goto fail;
1924 
1925  /* Import the gdb module to finish the initialization, and
1926  add it to __main__ for convenience. */
1927  m = PyImport_AddModule ("__main__");
1928  if (m == NULL)
1929  goto fail;
1930 
1931  gdb_python_module = PyImport_ImportModule ("gdb");
1932  if (gdb_python_module == NULL)
1933  {
1934  gdbpy_print_stack ();
1935  /* This is passed in one call to warning so that blank lines aren't
1936  inserted between each line of text. */
1937  warning (_("\n"
1938  "Could not load the Python gdb module from `%s'.\n"
1939  "Limited Python support is available from the _gdb module.\n"
1940  "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1941  gdb_pythondir);
1942  do_cleanups (cleanup);
1943  return;
1944  }
1945 
1946  if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0)
1947  goto fail;
1948 
1949  /* Keep the reference to gdb_python_module since it is in a global
1950  variable. */
1951 
1952  do_cleanups (cleanup);
1953  return;
1954 
1955  fail:
1956  gdbpy_print_stack ();
1957  warning (_("internal error: Unhandled Python exception"));
1958  do_cleanups (cleanup);
1959 }
1960 
1961 /* Return non-zero if Python has successfully initialized.
1962  This is the extension_languages_ops.initialized "method". */
1963 
1964 static int
1966 {
1967  return gdb_python_initialized;
1968 }
1969 
1970 #endif /* HAVE_PYTHON */
1971 
1972 
1973 
1974 #ifdef HAVE_PYTHON
1975 
1976 PyMethodDef python_GdbMethods[] =
1977 {
1978  { "history", gdbpy_history, METH_VARARGS,
1979  "Get a value from history" },
1980  { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1981  "execute (command [, from_tty] [, to_string]) -> [String]\n\
1982 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1983 a Python String containing the output of the command if to_string is\n\
1984 set to True." },
1985  { "parameter", gdbpy_parameter, METH_VARARGS,
1986  "Return a gdb parameter's value" },
1987 
1988  { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1989  "Return a tuple of all breakpoint objects" },
1990 
1991  { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1992  "Find the default visualizer for a Value." },
1993 
1994  { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1995  "Return the current Progspace." },
1996  { "progspaces", gdbpy_progspaces, METH_NOARGS,
1997  "Return a sequence of all progspaces." },
1998 
1999  { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
2000  "Return the current Objfile being loaded, or None." },
2001  { "objfiles", gdbpy_objfiles, METH_NOARGS,
2002  "Return a sequence of all loaded objfiles." },
2003 
2004  { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
2005  "newest_frame () -> gdb.Frame.\n\
2006 Return the newest frame object." },
2007  { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
2008  "selected_frame () -> gdb.Frame.\n\
2009 Return the selected frame object." },
2010  { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
2011  "stop_reason_string (Integer) -> String.\n\
2012 Return a string explaining unwind stop reason." },
2013 
2014  { "lookup_type", (PyCFunction) gdbpy_lookup_type,
2015  METH_VARARGS | METH_KEYWORDS,
2016  "lookup_type (name [, block]) -> type\n\
2017 Return a Type corresponding to the given name." },
2018  { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
2019  METH_VARARGS | METH_KEYWORDS,
2020  "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2021 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2022 a boolean indicating if name is a field of the current implied argument\n\
2023 `this' (when the current language is object-oriented)." },
2024  { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
2025  METH_VARARGS | METH_KEYWORDS,
2026  "lookup_global_symbol (name [, domain]) -> symbol\n\
2027 Return the symbol corresponding to the given name (or None)." },
2028 
2029  { "lookup_objfile", (PyCFunction) gdbpy_lookup_objfile,
2030  METH_VARARGS | METH_KEYWORDS,
2031  "lookup_objfile (name, [by_build_id]) -> objfile\n\
2032 Look up the specified objfile.\n\
2033 If by_build_id is True, the objfile is looked up by using name\n\
2034 as its build id." },
2035 
2036  { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
2037  "Return the block containing the given pc value, or None." },
2038  { "solib_name", gdbpy_solib_name, METH_VARARGS,
2039  "solib_name (Long) -> String.\n\
2040 Return the name of the shared library holding a given address, or None." },
2041  { "decode_line", gdbpy_decode_line, METH_VARARGS,
2042  "decode_line (String) -> Tuple. Decode a string argument the way\n\
2043 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2044 The first element contains any unparsed portion of the String parameter\n\
2045 (or None if the string was fully parsed). The second element contains\n\
2046 a tuple that contains all the locations that match, represented as\n\
2047 gdb.Symtab_and_line objects (or None)."},
2048  { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
2049  "parse_and_eval (String) -> Value.\n\
2050 Parse String as an expression, evaluate it, and return the result as a Value."
2051  },
2052  { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
2053  "find_pc_line (pc) -> Symtab_and_line.\n\
2054 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2055 
2056  { "post_event", gdbpy_post_event, METH_VARARGS,
2057  "Post an event into gdb's event loop." },
2058 
2059  { "target_charset", gdbpy_target_charset, METH_NOARGS,
2060  "target_charset () -> string.\n\
2061 Return the name of the current target charset." },
2062  { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
2063  "target_wide_charset () -> string.\n\
2064 Return the name of the current target wide charset." },
2065 
2066  { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
2067  "string_to_argv (String) -> Array.\n\
2068 Parse String and return an argv-like array.\n\
2069 Arguments are separate by spaces and may be quoted."
2070  },
2071  { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
2072  "Write a string using gdb's filtered stream." },
2073  { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
2074  "Flush gdb's filtered stdout stream." },
2075  { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
2076  "selected_thread () -> gdb.InferiorThread.\n\
2077 Return the selected thread object." },
2078  { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
2079  "selected_inferior () -> gdb.Inferior.\n\
2080 Return the selected inferior object." },
2081  { "inferiors", gdbpy_inferiors, METH_NOARGS,
2082  "inferiors () -> (gdb.Inferior, ...).\n\
2083 Return a tuple containing all inferiors." },
2084  {NULL, NULL, 0, NULL}
2085 };
2086 
2087 #ifdef IS_PY3K
2088 struct PyModuleDef python_GdbModuleDef =
2089 {
2090  PyModuleDef_HEAD_INIT,
2091  "_gdb",
2092  NULL,
2093  -1,
2095  NULL,
2096  NULL,
2097  NULL,
2098  NULL
2099 };
2100 #endif
2101 #endif /* HAVE_PYTHON */
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
int gdbpy_initialize_xmethods(void)
Definition: py-xmethods.c:728
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:437
PyObject * gdbpy_breakpoints(PyObject *self, PyObject *args)
int body_count
Definition: defs.h:413
void * gdbpy_clone_xmethod_worker_data(const struct extension_language_defn *extlang, void *data)
Definition: py-xmethods.c:75
#define Py_DECREF(op)
int gdbpy_initialize_signal_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
int serial_pipe(struct serial *scbs[2])
Definition: serial.c:595
int gdbpy_initialize_symbols(void)
Definition: py-symbol.c:497
static PyObject * gdbpy_flush(PyObject *self, PyObject *args, PyObject *kw)
Definition: python.c:1158
#define PyObject_GetAttrString(obj, attr)
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
PyObject * gdbpy_selected_frame(PyObject *self, PyObject *args)
Definition: py-frame.c:633
const char * target_charset(struct gdbarch *gdbarch)
Definition: charset.c:407
PyObject * gdbpy_display_hint_cst
Definition: python.c:118
int gdbpy_initialize_inferior_call_post_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
int gdbpy_print_python_errors_p(void)
Definition: python.c:1189
char * python_libdir
Definition: main.c:69
int gdbpy_initialize_thread(void)
Definition: py-infthread.c:272
int gdbpy_initialize_py_events(void)
Definition: py-evts.c:56
int gdbpy_initialize_finishbreakpoints(void)
static char * compute_python_string(struct command_line *l)
Definition: python.c:420
FILE * instream
Definition: top.c:109
PyObject * symtab_and_line_to_sal_object(struct symtab_and_line sal)
Definition: py-symtab.c:435
enum command_control_type execute_control_command_untraced(struct command_line *cmd)
Definition: cli-script.c:645
bfd_vma CORE_ADDR
Definition: common-types.h:41
int gdbpy_initialize_unwind(void)
Definition: py-unwind.c:660
static enum ext_lang_rc gdbpy_apply_type_printers(const struct extension_language_defn *, const struct ext_lang_type_printers *, struct type *, char **)
Definition: python.c:1454
void xfree(void *)
Definition: common-utils.c:97
ext_lang_rc
void(* func)(char *)
int gdbpy_initialize_memory_changed_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:487
#define INT_MAX
Definition: defs.h:509
void set_default_source_symtab_and_line(void)
Definition: source.c:203
const struct language_defn * python_language
Definition: python.c:202
void warning(const char *fmt,...)
Definition: errors.c:26
static const char * gdbpy_should_print_stack
Definition: python.c:56
#define PyEval_ReleaseLock()
static void gdbpy_finish_initialization(const struct extension_language_defn *)
Definition: python.c:1882
enum ext_lang_bt_status gdbpy_apply_frame_filter(const struct extension_language_defn *extlang, struct frame_info *frame, int flags, enum ext_lang_frame_args args_type, struct ui_out *out, int frame_low, int frame_high)
int gdbpy_initialize_breakpoints(void)
enum ext_lang_rc gdbpy_get_xmethod_arg_types(const struct extension_language_defn *extlang, struct xmethod_worker *worker, int *nargs, struct type ***arg_types)
Definition: py-xmethods.c:378
unsigned long gdb_py_ulongest
enum ext_lang_rc gdbpy_get_matching_xmethod_workers(const struct extension_language_defn *extlang, struct type *obj_type, const char *method_name, xmethod_worker_vec **dm_vec)
Definition: py-xmethods.c:163
struct gdbarch * python_gdbarch
Definition: python.c:201
char * gdbpy_obj_to_string(PyObject *obj)
Definition: py-utils.c:242
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:181
void objfile_script_executor_func(const struct extension_language_defn *, struct objfile *, const char *name, const char *script)
Definition: extension.h:54
struct ui_file * gdb_stdout
Definition: main.c:71
static void gdbpy_free_type_printers(const struct extension_language_defn *, struct ext_lang_type_printers *)
Definition: python.c:1523
static PyObject * gdbpy_target_charset(PyObject *self, PyObject *args)
Definition: python.c:604
PyGILState_STATE state
Definition: python.c:210
static void user_show_python(char *args, int from_tty)
Definition: python.c:1588
int gdbpy_initialize_arch(void)
Definition: py-arch.c:261
struct active_ext_lang_state * previous_active
Definition: python.c:209
char * ldirname(const char *filename)
Definition: utils.c:3006
int gdbpy_initialize_frames(void)
Definition: py-frame.c:703
int gdbpy_initialize_lazy_string(void)
char * execute_command_to_string(char *p, int from_tty)
Definition: top.c:488
const struct gdb_exception exception_none
int serial_write(struct serial *scb, const void *buf, size_t count)
Definition: serial.c:403
static PyObject * gdbpy_target_wide_charset(PyObject *self, PyObject *args)
Definition: python.c:614
int gdbpy_initialize_blocks(void)
Definition: py-block.c:430
PyObject * gdbpy_to_string_cst
Definition: python.c:116
char * skip_spaces(char *chp)
Definition: common-utils.c:259
#define _(String)
Definition: gdb_locale.h:40
static void gdbpy_run_events(struct serial *scb, void *context)
Definition: python.c:934
void execute_command(char *, int)
Definition: top.c:388
struct value * gdbpy_invoke_xmethod(const struct extension_language_defn *extlang, struct xmethod_worker *worker, struct value *obj, struct value **args, int nargs)
Definition: py-xmethods.c:610
PyObject * gdbpy_lookup_type(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-type.c:1405
PyObject * gdbpy_enabled_cst
Definition: python.c:120
long gdb_py_longest
static void gdbpy_eval_from_control_command(const struct extension_language_defn *, struct command_line *cmd)
Definition: python.c:448
#define END_CATCH
struct cmd_list_element * prefix
Definition: cli-decode.h:162
var_types
Definition: command.h:60
int lookup_cmd_composition(const char *text, struct cmd_list_element **alias, struct cmd_list_element **prefix_cmd, struct cmd_list_element **cmd)
Definition: cli-decode.c:1671
void serial_async(struct serial *scb, serial_event_ftype *handler, void *context)
Definition: serial.c:548
static const char python_excp_message[]
Definition: python.c:41
tuple m
Definition: arm-linux.py:44
int gdb_python_initialized
Definition: python.c:104
static const char python_excp_none[]
Definition: python.c:39
static const char *const python_excp_enums[]
Definition: python.c:44
int gdbpy_initialize_register_changed_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
static void restore_python_env(void *p)
Definition: python.c:217
int gdbpy_initialize_inferior(void)
Definition: py-inferior.c:872
int gdbpy_breakpoint_has_cond(const struct extension_language_defn *extlang, struct breakpoint *b)
static int gdbpy_initialized(const struct extension_language_defn *)
Definition: python.c:1965
int gdbpy_initialize_auto_load(void)
Definition: py-auto-load.c:61
int gdbpy_initialize_continue_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
PyObject * gdbpy_gdb_memory_error
Definition: python.c:130
#define GDB_PY_HANDLE_EXCEPTION(Exception)
PyObject * gdb_python_module
Definition: python.c:113
void null_cleanup(void *arg)
Definition: cleanups.c:295
PyObject * gdbpy_history(PyObject *self, PyObject *args)
Definition: py-value.c:1676
#define TRY
struct active_ext_lang_state * set_active_ext_lang(const struct extension_language_defn *)
Definition: extension.c:743
PyObject * gdbpy_frame_stop_reason_string(PyObject *self, PyObject *args)
Definition: py-frame.c:654
struct command_line * get_command_line(enum command_control_type type, char *arg)
Definition: cli-script.c:130
char * line
Definition: defs.h:400
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
#define PyGILState_Ensure()
int gdbpy_initialize_parameters(void)
Definition: py-param.c:754
#define SLASH_STRING
Definition: host-defs.h:58
static struct gdbpy_event ** gdbpy_event_list_end
Definition: python.c:923
#define CATCH(EXCEPTION, MASK)
int gdbpy_initialize_values(void)
Definition: py-value.c:1706
struct cleanup * make_cleanup_restore_integer(int *variable)
Definition: utils.c:292
struct cleanup * ensure_python_env(struct gdbarch *gdbarch, const struct language_defn *language)
Definition: python.c:247
static void gdbpy_start_type_printers(const struct extension_language_defn *, struct ext_lang_type_printers *)
Definition: python.c:1409
void objfile_script_sourcer_func(const struct extension_language_defn *, struct objfile *, FILE *stream, const char *filename)
Definition: extension.h:48
#define HAVE_PYTHON
Definition: config.h:383
PyMethodDef python_GdbMethods[]
Definition: python.c:1976
static struct gdbpy_event * gdbpy_event_list
Definition: python.c:921
void initialize_file_ftype(void)
Definition: defs.h:281
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
#define UINT_MAX
Definition: defs.h:505
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
const char * target_wide_charset(struct gdbarch *gdbarch)
Definition: charset.c:415
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t err
Definition: gnu-nat.c:1816
static PyObject * gdbpy_progspaces(PyObject *unused1, PyObject *unused2)
Definition: python.c:1280
struct gdbpy_event * next
Definition: python.c:917
enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop(const struct extension_language_defn *extlang, struct breakpoint *b)
PyObject * gdbpy_selected_inferior(PyObject *self, PyObject *args)
Definition: py-inferior.c:866
PyObject * gdbpy_gdb_error
Definition: python.c:127
int gdbpy_initialize_exited_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
PyObject * gdbpy_block_for_pc(PyObject *self, PyObject *args)
Definition: py-block.c:371
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
PyObject * gdbpy_gdberror_exc
Definition: python.c:124
#define PyGILState_Release(ARG)
struct cmd_list_element * add_com_alias(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag)
Definition: cli-decode.c:882
#define GDB_PY_LLU_ARG
struct symtabs_and_lines decode_line_1(char **argptr, int flags, struct symtab *default_symtab, int default_line)
Definition: linespec.c:2518
struct gdbarch * gdbarch
Definition: python.c:211
PyObject * gdbpy_newest_frame(PyObject *self, PyObject *args)
Definition: py-frame.c:612
int gdbpy_initialize_event(void)
Definition: py-event.c:64
__extension__ enum var_types var_type
Definition: cli-decode.h:104
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static objfile_script_executor_func gdbpy_execute_objfile_script
Definition: python.c:134
PyObject * error_traceback
Definition: python.c:213
PyObject * gdbpy_parameter_value(enum var_types type, void *var)
Definition: python.c:504
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
char * python_string_to_host_string(PyObject *obj)
Definition: py-utils.c:210
const char version[]
Definition: version.c:2
char * solib_name_from_address(struct program_space *pspace, CORE_ADDR address)
Definition: solib.c:1191
int gdbpy_initialize_commands(void)
Definition: py-cmd.c:676
Definition: gdbtypes.h:749
PyObject * objfile_to_objfile_object(struct objfile *objfile)
Definition: py-objfile.c:632
PyObject * gdbpy_doc_cst
Definition: python.c:119
int interpreter_async
Definition: interps.c:46
char * gdb_datadir
Definition: main.c:60
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
void script_sourcer_func(const struct extension_language_defn *, FILE *stream, const char *filename)
Definition: extension.h:41
PyObject * gdbpy_lookup_objfile(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-objfile.c:564
int gdbpy_initialize_objfile(void)
Definition: py-objfile.c:657
struct cleanup * prevent_dont_repeat(void)
Definition: top.c:598
#define PyThreadState_Swap(ARG)
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1523
Definition: serial.h:227
enum ext_lang_rc gdbpy_get_xmethod_result_type(const struct extension_language_defn *extlang, struct xmethod_worker *worker, struct value *obj, struct value **args, int nargs, struct type **result_type_ptr)
Definition: py-xmethods.c:510
static PyObject * gdbpy_parse_and_eval(PyObject *self, PyObject *args)
Definition: python.c:839
static void user_set_python(char *args, int from_tty)
Definition: python.c:1579
PyObject * gdbpy_lookup_symbol(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-symbol.c:365
static int gdbpy_check_quit_flag(const struct extension_language_defn *)
Definition: python.c:291
static const char python_excp_full[]
Definition: python.c:40
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
PyObject * gdbpy_parameter(PyObject *self, PyObject *args)
Definition: python.c:566
const struct extension_language_script_ops python_extension_script_ops
Definition: python.c:155
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:672
#define GDB_PY_LL_ARG
static PyObject * gdbpy_decode_line(PyObject *self, PyObject *args)
Definition: python.c:721
enum ext_lang_rc gdbpy_apply_val_pretty_printer(const struct extension_language_defn *extlang, struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options, const struct language_defn *language)
PyObject * gdbpy_selected_thread(PyObject *self, PyObject *args)
Definition: py-infthread.c:257
int gdbpy_auto_load_enabled(const struct extension_language_defn *extlang)
Definition: py-auto-load.c:47
Definition: value.c:172
void gdbpy_preserve_values(const struct extension_language_defn *extlang, struct objfile *objfile, htab_t copied_types)
Definition: py-value.c:162
PyObject * event
Definition: python.c:915
static int gdbpy_initialize_events(void)
Definition: python.c:1014
int gdbpy_initialize_symtabs(void)
Definition: py-symtab.c:521
int gdbpy_initialize_pspace(void)
Definition: py-progspace.c:375
struct command_line * next
Definition: defs.h:399
static enum ext_lang_rc gdbpy_before_prompt_hook(const struct extension_language_defn *, const char *current_gdb_prompt)
Definition: python.c:1030
PyObject * gdbpy_string_to_argv(PyObject *self, PyObject *args)
Definition: py-cmd.c:786
#define PyEval_InitThreads()
static PyObject * gdbpy_objfiles(PyObject *unused1, PyObject *unused2)
Definition: python.c:1380
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
const struct language_defn * current_language
Definition: language.c:85
static void finalize_python(void *ignore)
Definition: python.c:1601
#define ALL_PSPACES(pspace)
Definition: progspace.h:232
initialize_file_ftype _initialize_python
int gdbpy_initialize_breakpoint_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
static void python_interactive_command(char *arg, int from_tty)
Definition: python.c:328
int gdbpy_initialize_types(void)
Definition: py-type.c:1436
void gdbpy_convert_exception(struct gdb_exception exception)
Definition: py-utils.c:295
PyObject * gdbpy_default_visualizer(PyObject *self, PyObject *args)
struct ui_file * gdb_stderr
Definition: main.c:72
static objfile_script_sourcer_func gdbpy_source_objfile_script
Definition: python.c:133
static void python_command(char *arg, int from_tty)
Definition: python.c:472
PyObject * gdb_module
Definition: python.c:112
void set_prompt(const char *s)
Definition: top.c:1394
const char host_name[]
Definition: version.c:3
static PyObject * gdbpy_get_current_progspace(PyObject *unused1, PyObject *unused2)
Definition: python.c:1267
int gdbpy_initialize_inferior_call_pre_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
PyObject * gdbpy_lookup_global_symbol(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-symbol.c:438
PyObject * gdbpy_children_cst
Definition: python.c:117
CORE_ADDR pc
Definition: symtab.h:1376
int gdbpy_initialize_functions(void)
Definition: py-function.c:203
void gdbpy_free_xmethod_worker_data(const struct extension_language_defn *extlang, void *data)
Definition: py-xmethods.c:54
static script_sourcer_func gdbpy_source_script
Definition: python.c:132
const char target_name[]
Definition: version.c:4
int gdbpy_initialize_linetable(void)
Definition: py-linetable.c:324
static PyObject * gdbpy_write(PyObject *self, PyObject *args, PyObject *kw)
Definition: python.c:1116
static PyObject * gdbpy_get_current_objfile(PyObject *unused1, PyObject *unused2)
Definition: python.c:1364
struct cleanup * make_cleanup_free_command_lines(struct command_line **arg)
Definition: cli-script.c:1405
PyObject * error_type
Definition: python.c:213
struct cleanup * make_final_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:136
auto_boolean
Definition: defs.h:196
static void gdbpy_clear_quit_flag(const struct extension_language_defn *)
Definition: python.c:274
struct program_space * current_program_space
Definition: progspace.c:35
struct value * parse_and_eval(const char *exp)
Definition: eval.c:124
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
static void gdbpy_set_quit_flag(const struct extension_language_defn *)
Definition: python.c:283
language
Definition: defs.h:167
PyObject * error_value
Definition: python.c:213
int gdbpy_initialize_stop_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
static PyObject * gdbpy_solib_name(PyObject *self, PyObject *args)
Definition: python.c:697
const struct language_defn * language
Definition: python.c:212
static struct cmd_list_element * user_show_python_list
Definition: python.c:1574
static PyObject * gdbpy_find_pc_line(PyObject *self, PyObject *args)
Definition: python.c:864
Definition: ia64-tdep.c:84
void gdbpy_print_stack(void)
Definition: python.c:1199
void bpstat_do_actions(void)
Definition: breakpoint.c:4668
PyObject * gdbpy_value_cst
Definition: python.c:121
struct symtab_and_line * sals
Definition: symtab.h:1392
static struct cmd_list_element * user_set_python_list
Definition: python.c:1573
static PyObject * execute_gdb_command(PyObject *self, PyObject *args, PyObject *kw)
Definition: python.c:624
static struct objfile * gdbpy_current_objfile
Definition: python.c:1309
const char * host_charset(void)
Definition: charset.c:399
static void python_run_simple_file(FILE *file, const char *filename)
Definition: python.c:383
int gdbpy_initialize_eventregistry(void)
struct cleanup * make_cleanup_py_decref(PyObject *py)
Definition: py-utils.c:41
void * arg
Definition: cleanups.c:43
void gdbpy_initialize_gdb_readline(void)
void dont_repeat(void)
Definition: top.c:582
int serial_readchar(struct serial *scb, int timeout)
Definition: serial.c:372
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
static int eval_python_command(const char *command)
Definition: python.c:301
int gdbpy_initialize_new_objfile_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
int gdbpy_initialize_clear_objfiles_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
PyObject * gdbpy_inferiors(PyObject *unused, PyObject *unused2)
Definition: py-inferior.c:478
int gdbpy_initialize_thread_event(void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
static PyObject * gdbpy_post_event(PyObject *self, PyObject *args)
Definition: python.c:972
void restore_active_ext_lang(struct active_ext_lang_state *previous)
Definition: extension.c:769
struct command_line ** body_list
Definition: defs.h:417
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
PyObject * pspace_to_pspace_object(struct program_space *pspace)
Definition: py-progspace.c:350
#define PyObject_HasAttrString(obj, attr)
char * gdbpy_exception_to_string(PyObject *ptype, PyObject *pvalue)
Definition: py-utils.c:268
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void begin_line(void)
Definition: utils.c:2016
enum return_reason reason
const ULONGEST const LONGEST len
Definition: target.h:309
PyObject * type_to_type_object(struct type *type)
Definition: py-type.c:1382