GDB (xrefs)

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