14da62c
[binutils-gdb.git] /
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 #include "location.h"
38
39 /* Declared constants and enum for python stack printing. */
40 static const char python_excp_none[] = "none";
41 static const char python_excp_full[] = "full";
42 static const char python_excp_message[] = "message";
43
44 /* "set python print-stack" choices. */
45 static const char *const python_excp_enums[] =
46 {
47 python_excp_none,
48 python_excp_full,
49 python_excp_message,
50 NULL
51 };
52
53 /* The exception printing variable. 'full' if we want to print the
54 error message and stack, 'none' if we want to print nothing, and
55 'message' if we only want to print the error message. 'message' is
56 the default. */
57 static const char *gdbpy_should_print_stack = python_excp_message;
58
59 #ifdef HAVE_PYTHON
60 /* Forward decls, these are defined later. */
61 extern const struct extension_language_script_ops python_extension_script_ops;
62 extern const struct extension_language_ops python_extension_ops;
63 #endif
64
65 /* The main struct describing GDB's interface to the Python
66 extension language. */
67 const struct extension_language_defn extension_language_python =
68 {
69 EXT_LANG_PYTHON,
70 "python",
71 "Python",
72
73 ".py",
74 "-gdb.py",
75
76 python_control,
77
78 #ifdef HAVE_PYTHON
79 &python_extension_script_ops,
80 &python_extension_ops
81 #else
82 NULL,
83 NULL
84 #endif
85 };
86 \f
87 #ifdef HAVE_PYTHON
88
89 #include "cli/cli-decode.h"
90 #include "charset.h"
91 #include "top.h"
92 #include "solib.h"
93 #include "python-internal.h"
94 #include "linespec.h"
95 #include "source.h"
96 #include "version.h"
97 #include "target.h"
98 #include "gdbthread.h"
99 #include "interps.h"
100 #include "event-top.h"
101
102 /* True if Python has been successfully initialized, false
103 otherwise. */
104
105 int gdb_python_initialized;
106
107 extern PyMethodDef python_GdbMethods[];
108
109 #ifdef IS_PY3K
110 extern struct PyModuleDef python_GdbModuleDef;
111 #endif
112
113 PyObject *gdb_module;
114 PyObject *gdb_python_module;
115
116 /* Some string constants we may wish to use. */
117 PyObject *gdbpy_to_string_cst;
118 PyObject *gdbpy_children_cst;
119 PyObject *gdbpy_display_hint_cst;
120 PyObject *gdbpy_doc_cst;
121 PyObject *gdbpy_enabled_cst;
122 PyObject *gdbpy_value_cst;
123
124 /* The GdbError exception. */
125 PyObject *gdbpy_gdberror_exc;
126
127 /* The `gdb.error' base class. */
128 PyObject *gdbpy_gdb_error;
129
130 /* The `gdb.MemoryError' exception. */
131 PyObject *gdbpy_gdb_memory_error;
132
133 static script_sourcer_func gdbpy_source_script;
134 static objfile_script_sourcer_func gdbpy_source_objfile_script;
135 static objfile_script_executor_func gdbpy_execute_objfile_script;
136 static void gdbpy_finish_initialization
137 (const struct extension_language_defn *);
138 static int gdbpy_initialized (const struct extension_language_defn *);
139 static void gdbpy_eval_from_control_command
140 (const struct extension_language_defn *, struct command_line *cmd);
141 static void gdbpy_start_type_printers (const struct extension_language_defn *,
142 struct ext_lang_type_printers *);
143 static enum ext_lang_rc gdbpy_apply_type_printers
144 (const struct extension_language_defn *,
145 const struct ext_lang_type_printers *, struct type *, char **);
146 static void gdbpy_free_type_printers (const struct extension_language_defn *,
147 struct ext_lang_type_printers *);
148 static void gdbpy_clear_quit_flag (const struct extension_language_defn *);
149 static void gdbpy_set_quit_flag (const struct extension_language_defn *);
150 static int gdbpy_check_quit_flag (const struct extension_language_defn *);
151 static enum ext_lang_rc gdbpy_before_prompt_hook
152 (const struct extension_language_defn *, const char *current_gdb_prompt);
153
154 /* The interface between gdb proper and loading of python scripts. */
155
156 const struct extension_language_script_ops python_extension_script_ops =
157 {
158 gdbpy_source_script,
159 gdbpy_source_objfile_script,
160 gdbpy_execute_objfile_script,
161 gdbpy_auto_load_enabled
162 };
163
164 /* The interface between gdb proper and python extensions. */
165
166 const struct extension_language_ops python_extension_ops =
167 {
168 gdbpy_finish_initialization,
169 gdbpy_initialized,
170
171 gdbpy_eval_from_control_command,
172
173 gdbpy_start_type_printers,
174 gdbpy_apply_type_printers,
175 gdbpy_free_type_printers,
176
177 gdbpy_apply_val_pretty_printer,
178
179 gdbpy_apply_frame_filter,
180
181 gdbpy_preserve_values,
182
183 gdbpy_breakpoint_has_cond,
184 gdbpy_breakpoint_cond_says_stop,
185
186 gdbpy_clear_quit_flag,
187 gdbpy_set_quit_flag,
188 gdbpy_check_quit_flag,
189
190 gdbpy_before_prompt_hook,
191
192 gdbpy_clone_xmethod_worker_data,
193 gdbpy_free_xmethod_worker_data,
194 gdbpy_get_matching_xmethod_workers,
195 gdbpy_get_xmethod_arg_types,
196 gdbpy_get_xmethod_result_type,
197 gdbpy_invoke_xmethod
198 };
199
200 /* Architecture and language to be used in callbacks from
201 the Python interpreter. */
202 struct gdbarch *python_gdbarch;
203 const struct language_defn *python_language;
204
205 /* Restore global language and architecture and Python GIL state
206 when leaving the Python interpreter. */
207
208 struct python_env
209 {
210 struct active_ext_lang_state *previous_active;
211 PyGILState_STATE state;
212 struct gdbarch *gdbarch;
213 const struct language_defn *language;
214 PyObject *error_type, *error_value, *error_traceback;
215 };
216
217 static void
218 restore_python_env (void *p)
219 {
220 struct python_env *env = (struct python_env *)p;
221
222 /* Leftover Python error is forbidden by Python Exception Handling. */
223 if (PyErr_Occurred ())
224 {
225 /* This order is similar to the one calling error afterwards. */
226 gdbpy_print_stack ();
227 warning (_("internal error: Unhandled Python exception"));
228 }
229
230 PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
231
232 PyGILState_Release (env->state);
233 python_gdbarch = env->gdbarch;
234 python_language = env->language;
235
236 restore_active_ext_lang (env->previous_active);
237
238 xfree (env);
239 }
240
241 /* Called before entering the Python interpreter to install the
242 current language and architecture to be used for Python values.
243 Also set the active extension language for GDB so that SIGINT's
244 are directed our way, and if necessary install the right SIGINT
245 handler. */
246
247 struct cleanup *
248 ensure_python_env (struct gdbarch *gdbarch,
249 const struct language_defn *language)
250 {
251 struct python_env *env = xmalloc (sizeof *env);
252
253 /* We should not ever enter Python unless initialized. */
254 if (!gdb_python_initialized)
255 error (_("Python not initialized"));
256
257 env->previous_active = set_active_ext_lang (&extension_language_python);
258
259 env->state = PyGILState_Ensure ();
260 env->gdbarch = python_gdbarch;
261 env->language = python_language;
262
263 python_gdbarch = gdbarch;
264 python_language = language;
265
266 /* Save it and ensure ! PyErr_Occurred () afterwards. */
267 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
268
269 return make_cleanup (restore_python_env, env);
270 }
271
272 /* Clear the quit flag. */
273
274 static void
275 gdbpy_clear_quit_flag (const struct extension_language_defn *extlang)
276 {
277 /* This clears the flag as a side effect. */
278 PyOS_InterruptOccurred ();
279 }
280
281 /* Set the quit flag. */
282
283 static void
284 gdbpy_set_quit_flag (const struct extension_language_defn *extlang)
285 {
286 PyErr_SetInterrupt ();
287 }
288
289 /* Return true if the quit flag has been set, false otherwise. */
290
291 static int
292 gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
293 {
294 return PyOS_InterruptOccurred ();
295 }
296
297 /* Evaluate a Python command like PyRun_SimpleString, but uses
298 Py_single_input which prints the result of expressions, and does
299 not automatically print the stack on errors. */
300
301 static int
302 eval_python_command (const char *command)
303 {
304 PyObject *m, *d, *v;
305
306 m = PyImport_AddModule ("__main__");
307 if (m == NULL)
308 return -1;
309
310 d = PyModule_GetDict (m);
311 if (d == NULL)
312 return -1;
313 v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
314 if (v == NULL)
315 return -1;
316
317 Py_DECREF (v);
318 #ifndef IS_PY3K
319 if (Py_FlushLine ())
320 PyErr_Clear ();
321 #endif
322
323 return 0;
324 }
325
326 /* Implementation of the gdb "python-interactive" command. */
327
328 static void
329 python_interactive_command (char *arg, int from_tty)
330 {
331 struct cleanup *cleanup;
332 int err;
333
334 cleanup = make_cleanup_restore_integer (&interpreter_async);
335 interpreter_async = 0;
336
337 arg = skip_spaces (arg);
338
339 ensure_python_env (get_current_arch (), current_language);
340
341 if (arg && *arg)
342 {
343 int len = strlen (arg);
344 char *script = xmalloc (len + 2);
345
346 strcpy (script, arg);
347 script[len] = '\n';
348 script[len + 1] = '\0';
349 err = eval_python_command (script);
350 xfree (script);
351 }
352 else
353 {
354 err = PyRun_InteractiveLoop (instream, "<stdin>");
355 dont_repeat ();
356 }
357
358 if (err)
359 {
360 gdbpy_print_stack ();
361 error (_("Error while executing Python code."));
362 }
363
364 do_cleanups (cleanup);
365 }
366
367 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
368 named FILENAME.
369
370 On Windows hosts few users would build Python themselves (this is no
371 trivial task on this platform), and thus use binaries built by
372 someone else instead. There may happen situation where the Python
373 library and GDB are using two different versions of the C runtime
374 library. Python, being built with VC, would use one version of the
375 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
376 A FILE * from one runtime does not necessarily operate correctly in
377 the other runtime.
378
379 To work around this potential issue, we create on Windows hosts the
380 FILE object using Python routines, thus making sure that it is
381 compatible with the Python library. */
382
383 static void
384 python_run_simple_file (FILE *file, const char *filename)
385 {
386 #ifndef _WIN32
387
388 PyRun_SimpleFile (file, filename);
389
390 #else /* _WIN32 */
391
392 char *full_path;
393 PyObject *python_file;
394 struct cleanup *cleanup;
395
396 /* Because we have a string for a filename, and are using Python to
397 open the file, we need to expand any tilde in the path first. */
398 full_path = tilde_expand (filename);
399 cleanup = make_cleanup (xfree, full_path);
400 python_file = PyFile_FromString (full_path, "r");
401 if (! python_file)
402 {
403 do_cleanups (cleanup);
404 gdbpy_print_stack ();
405 error (_("Error while opening file: %s"), full_path);
406 }
407
408 make_cleanup_py_decref (python_file);
409 PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
410 do_cleanups (cleanup);
411
412 #endif /* _WIN32 */
413 }
414
415 /* Given a command_line, return a command string suitable for passing
416 to Python. Lines in the string are separated by newlines. The
417 return value is allocated using xmalloc and the caller is
418 responsible for freeing it. */
419
420 static char *
421 compute_python_string (struct command_line *l)
422 {
423 struct command_line *iter;
424 char *script = NULL;
425 int size = 0;
426 int here;
427
428 for (iter = l; iter; iter = iter->next)
429 size += strlen (iter->line) + 1;
430
431 script = xmalloc (size + 1);
432 here = 0;
433 for (iter = l; iter; iter = iter->next)
434 {
435 int len = strlen (iter->line);
436
437 strcpy (&script[here], iter->line);
438 here += len;
439 script[here++] = '\n';
440 }
441 script[here] = '\0';
442 return script;
443 }
444
445 /* Take a command line structure representing a 'python' command, and
446 evaluate its body using the Python interpreter. */
447
448 static void
449 gdbpy_eval_from_control_command (const struct extension_language_defn *extlang,
450 struct command_line *cmd)
451 {
452 int ret;
453 char *script;
454 struct cleanup *cleanup;
455
456 if (cmd->body_count != 1)
457 error (_("Invalid \"python\" block structure."));
458
459 cleanup = ensure_python_env (get_current_arch (), current_language);
460
461 script = compute_python_string (cmd->body_list[0]);
462 ret = PyRun_SimpleString (script);
463 xfree (script);
464 if (ret)
465 error (_("Error while executing Python code."));
466
467 do_cleanups (cleanup);
468 }
469
470 /* Implementation of the gdb "python" command. */
471
472 static void
473 python_command (char *arg, int from_tty)
474 {
475 struct cleanup *cleanup;
476
477 cleanup = ensure_python_env (get_current_arch (), current_language);
478
479 make_cleanup_restore_integer (&interpreter_async);
480 interpreter_async = 0;
481
482 arg = skip_spaces (arg);
483 if (arg && *arg)
484 {
485 if (PyRun_SimpleString (arg))
486 error (_("Error while executing Python code."));
487 }
488 else
489 {
490 struct command_line *l = get_command_line (python_control, "");
491
492 make_cleanup_free_command_lines (&l);
493 execute_control_command_untraced (l);
494 }
495
496 do_cleanups (cleanup);
497 }
498
499 \f
500
501 /* Transform a gdb parameters's value into a Python value. May return
502 NULL (and set a Python exception) on error. Helper function for
503 get_parameter. */
504 PyObject *
505 gdbpy_parameter_value (enum var_types type, void *var)
506 {
507 switch (type)
508 {
509 case var_string:
510 case var_string_noescape:
511 case var_optional_filename:
512 case var_filename:
513 case var_enum:
514 {
515 char *str = * (char **) var;
516
517 if (! str)
518 str = "";
519 return PyString_Decode (str, strlen (str), host_charset (), NULL);
520 }
521
522 case var_boolean:
523 {
524 if (* (int *) var)
525 Py_RETURN_TRUE;
526 else
527 Py_RETURN_FALSE;
528 }
529
530 case var_auto_boolean:
531 {
532 enum auto_boolean ab = * (enum auto_boolean *) var;
533
534 if (ab == AUTO_BOOLEAN_TRUE)
535 Py_RETURN_TRUE;
536 else if (ab == AUTO_BOOLEAN_FALSE)
537 Py_RETURN_FALSE;
538 else
539 Py_RETURN_NONE;
540 }
541
542 case var_integer:
543 if ((* (int *) var) == INT_MAX)
544 Py_RETURN_NONE;
545 /* Fall through. */
546 case var_zinteger:
547 return PyLong_FromLong (* (int *) var);
548
549 case var_uinteger:
550 {
551 unsigned int val = * (unsigned int *) var;
552
553 if (val == UINT_MAX)
554 Py_RETURN_NONE;
555 return PyLong_FromUnsignedLong (val);
556 }
557 }
558
559 return PyErr_Format (PyExc_RuntimeError,
560 _("Programmer error: unhandled type."));
561 }
562
563 /* A Python function which returns a gdb parameter's value as a Python
564 value. */
565
566 PyObject *
567 gdbpy_parameter (PyObject *self, PyObject *args)
568 {
569 struct gdb_exception except = exception_none;
570 struct cmd_list_element *alias, *prefix, *cmd;
571 const char *arg;
572 char *newarg;
573 int found = -1;
574
575 if (! PyArg_ParseTuple (args, "s", &arg))
576 return NULL;
577
578 newarg = concat ("show ", arg, (char *) NULL);
579
580 TRY
581 {
582 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
583 }
584 CATCH (ex, RETURN_MASK_ALL)
585 {
586 except = ex;
587 }
588 END_CATCH
589
590 xfree (newarg);
591 GDB_PY_HANDLE_EXCEPTION (except);
592 if (!found)
593 return PyErr_Format (PyExc_RuntimeError,
594 _("Could not find parameter `%s'."), arg);
595
596 if (! cmd->var)
597 return PyErr_Format (PyExc_RuntimeError,
598 _("`%s' is not a parameter."), arg);
599 return gdbpy_parameter_value (cmd->var_type, cmd->var);
600 }
601
602 /* Wrapper for target_charset. */
603
604 static PyObject *
605 gdbpy_target_charset (PyObject *self, PyObject *args)
606 {
607 const char *cset = target_charset (python_gdbarch);
608
609 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
610 }
611
612 /* Wrapper for target_wide_charset. */
613
614 static PyObject *
615 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
616 {
617 const char *cset = target_wide_charset (python_gdbarch);
618
619 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
620 }
621
622 /* A Python function which evaluates a string using the gdb CLI. */
623
624 static PyObject *
625 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
626 {
627 const char *arg;
628 PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
629 int from_tty, to_string;
630 static char *keywords[] = {"command", "from_tty", "to_string", NULL };
631 char *result = NULL;
632
633 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
634 &PyBool_Type, &from_tty_obj,
635 &PyBool_Type, &to_string_obj))
636 return NULL;
637
638 from_tty = 0;
639 if (from_tty_obj)
640 {
641 int cmp = PyObject_IsTrue (from_tty_obj);
642 if (cmp < 0)
643 return NULL;
644 from_tty = cmp;
645 }
646
647 to_string = 0;
648 if (to_string_obj)
649 {
650 int cmp = PyObject_IsTrue (to_string_obj);
651 if (cmp < 0)
652 return NULL;
653 to_string = cmp;
654 }
655
656 TRY
657 {
658 /* Copy the argument text in case the command modifies it. */
659 char *copy = xstrdup (arg);
660 struct cleanup *cleanup = make_cleanup (xfree, copy);
661
662 make_cleanup_restore_integer (&interpreter_async);
663 interpreter_async = 0;
664
665 prevent_dont_repeat ();
666 if (to_string)
667 result = execute_command_to_string (copy, from_tty);
668 else
669 {
670 result = NULL;
671 execute_command (copy, from_tty);
672 }
673
674 do_cleanups (cleanup);
675 }
676 CATCH (except, RETURN_MASK_ALL)
677 {
678 GDB_PY_HANDLE_EXCEPTION (except);
679 }
680 END_CATCH
681
682 /* Do any commands attached to breakpoint we stopped at. */
683 bpstat_do_actions ();
684
685 if (result)
686 {
687 PyObject *r = PyString_FromString (result);
688 xfree (result);
689 return r;
690 }
691 Py_RETURN_NONE;
692 }
693
694 /* Implementation of gdb.solib_name (Long) -> String.
695 Returns the name of the shared library holding a given address, or None. */
696
697 static PyObject *
698 gdbpy_solib_name (PyObject *self, PyObject *args)
699 {
700 char *soname;
701 PyObject *str_obj;
702 gdb_py_longest pc;
703
704 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
705 return NULL;
706
707 soname = solib_name_from_address (current_program_space, pc);
708 if (soname)
709 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
710 else
711 {
712 str_obj = Py_None;
713 Py_INCREF (Py_None);
714 }
715
716 return str_obj;
717 }
718
719 /* A Python function which is a wrapper for decode_line_1. */
720
721 static PyObject *
722 gdbpy_decode_line (PyObject *self, PyObject *args)
723 {
724 struct gdb_exception except = exception_none;
725 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
726 appease gcc. */
727 struct symtab_and_line sal;
728 char *arg = NULL;
729 struct cleanup *cleanups;
730 PyObject *result = NULL;
731 PyObject *return_result = NULL;
732 PyObject *unparsed = NULL;
733 struct event_location *location = NULL;
734
735 if (! PyArg_ParseTuple (args, "|s", &arg))
736 return NULL;
737
738 cleanups = make_cleanup (null_cleanup, NULL);
739
740 sals.sals = NULL;
741
742 if (arg != NULL)
743 {
744 location = new_linespec_location (&arg);
745 make_cleanup_delete_event_location (location);
746 }
747
748 TRY
749 {
750 if (location != NULL)
751 sals = decode_line_1 (location, 0, 0, 0);
752 else
753 {
754 set_default_source_symtab_and_line ();
755 sal = get_current_source_symtab_and_line ();
756 sals.sals = &sal;
757 sals.nelts = 1;
758 }
759 }
760 CATCH (ex, RETURN_MASK_ALL)
761 {
762 except = ex;
763 }
764 END_CATCH
765
766 if (sals.sals != NULL && sals.sals != &sal)
767 make_cleanup (xfree, sals.sals);
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 (arg != NULL && strlen (arg) > 0)
812 {
813 unparsed = PyString_FromString (arg);
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
897 gdbpy_source_script (const struct extension_language_defn *extlang,
898 FILE *file, const char *filename)
899 {
900 struct cleanup *cleanup;
901
902 cleanup = ensure_python_env (get_current_arch (), current_language);
903 python_run_simple_file (file, filename);
904 do_cleanups (cleanup);
905 }
906
907 \f
908
909 /* Posting and handling events. */
910
911 /* A single event. */
912 struct gdbpy_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. */
921 static struct gdbpy_event *gdbpy_event_list;
922 /* The final link of the event list. */
923 static struct gdbpy_event **gdbpy_event_list_end;
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
938 cleanup = ensure_python_env (get_current_arch (), current_language);
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
1014 gdbpy_initialize_events (void)
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 \f
1026
1027 /* This is the extension_language_ops.before_prompt "method". */
1028
1029 static enum ext_lang_rc
1030 gdbpy_before_prompt_hook (const struct extension_language_defn *extlang,
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
1039 cleanup = ensure_python_env (get_current_arch (), current_language);
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 \f
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 {
1171 gdb_flush (gdb_stderr);
1172 break;
1173 }
1174 case 2:
1175 {
1176 gdb_flush (gdb_stdlog);
1177 break;
1178 }
1179 default:
1180 gdb_flush (gdb_stdout);
1181 }
1182
1183 Py_RETURN_NONE;
1184 }
1185
1186 /* Return non-zero if print-stack is not "none". */
1187
1188 int
1189 gdbpy_print_python_errors_p (void)
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
1199 gdbpy_print_stack (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. */
1241 fprintf_filtered (gdb_stderr,
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 \f
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
1271 result = pspace_to_pspace_object (current_program_space);
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 \f
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. */
1309 static struct objfile *gdbpy_current_objfile;
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
1318 gdbpy_source_objfile_script (const struct extension_language_defn *extlang,
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
1343 gdbpy_execute_objfile_script (const struct extension_language_defn *extlang,
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
1409 gdbpy_start_type_printers (const struct extension_language_defn *extlang,
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
1418 cleanups = ensure_python_env (get_current_arch (), current_language);
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
1454 gdbpy_apply_type_printers (const struct extension_language_defn *extlang,
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
1470 cleanups = ensure_python_env (get_current_arch (), current_language);
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
1523 gdbpy_free_type_printers (const struct extension_language_defn *extlang,
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
1535 cleanups = ensure_python_env (get_current_arch (), current_language);
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
1556 execute_control_command_untraced (l);
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 \f
1570
1571 /* Lists for 'set python' commands. */
1572
1573 static struct cmd_list_element *user_set_python_list;
1574 static struct cmd_list_element *user_show_python_list;
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
1601 finalize_python (void *ignore)
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. */
1626 extern initialize_file_ftype _initialize_python;
1627
1628 void
1629 _initialize_python (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,
1640 python_interactive_command,
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. */
1688 add_prefix_cmd ("python", no_class, user_show_python,
1689 _("Prefix command for python preference settings."),
1690 &user_show_python_list, "show python ", 0,
1691 &showlist);
1692
1693 add_prefix_cmd ("python", no_class, user_set_python,
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
1796 gdbpy_initialize_gdb_readline ();
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
1810 || gdbpy_initialize_breakpoints () < 0
1811 || gdbpy_initialize_finishbreakpoints () < 0
1812 || gdbpy_initialize_lazy_string () < 0
1813 || gdbpy_initialize_linetable () < 0
1814 || gdbpy_initialize_thread () < 0
1815 || gdbpy_initialize_inferior () < 0
1816 || gdbpy_initialize_events () < 0
1817 || gdbpy_initialize_eventregistry () < 0
1818 || gdbpy_initialize_py_events () < 0
1819 || gdbpy_initialize_event () < 0
1820 || gdbpy_initialize_stop_event () < 0
1821 || gdbpy_initialize_signal_event () < 0
1822 || gdbpy_initialize_breakpoint_event () < 0
1823 || gdbpy_initialize_continue_event () < 0
1824 || gdbpy_initialize_inferior_call_pre_event () < 0
1825 || gdbpy_initialize_inferior_call_post_event () < 0
1826 || gdbpy_initialize_register_changed_event () < 0
1827 || gdbpy_initialize_memory_changed_event () < 0
1828 || gdbpy_initialize_exited_event () < 0
1829 || gdbpy_initialize_thread_event () < 0
1830 || gdbpy_initialize_new_objfile_event () < 0
1831 || gdbpy_initialize_clear_objfiles_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
1860 make_final_cleanup (finalize_python, NULL);
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
1882 gdbpy_finish_initialization (const struct extension_language_defn *extlang)
1883 {
1884 PyObject *m;
1885 char *gdb_pythondir;
1886 PyObject *sys_path;
1887 struct cleanup *cleanup;
1888
1889 cleanup = ensure_python_env (get_current_arch (), current_language);
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
1965 gdbpy_initialized (const struct extension_language_defn *extlang)
1966 {
1967 return gdb_python_initialized;
1968 }
1969
1970 #endif /* HAVE_PYTHON */
1971
1972 \f
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,
2094 python_GdbMethods,
2095 NULL,
2096 NULL,
2097 NULL,
2098 NULL
2099 };
2100 #endif
2101 #endif /* HAVE_PYTHON */