]> Git Repo - binutils.git/blob - gdb/python/python-internal.h
24e28bc4767938501c5579708ed3e29528a29adb
[binutils.git] / gdb / python / python-internal.h
1 /* Gdb/Python header for private use by Python module.
2
3    Copyright (C) 2008-2021 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 #ifndef PYTHON_PYTHON_INTERNAL_H
21 #define PYTHON_PYTHON_INTERNAL_H
22
23 #include "extension.h"
24 #include "extension-priv.h"
25
26 /* These WITH_* macros are defined by the CPython API checker that
27    comes with the Python plugin for GCC.  See:
28    https://gcc-python-plugin.readthedocs.org/en/latest/cpychecker.html
29    The checker defines a WITH_ macro for each attribute it
30    exposes.  Note that we intentionally do not use
31    'cpychecker_returns_borrowed_ref' -- that idiom is forbidden in
32    gdb.  */
33
34 #ifdef WITH_CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF_ATTRIBUTE
35 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)         \
36   __attribute__ ((cpychecker_type_object_for_typedef (ARG)))
37 #else
38 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
39 #endif
40
41 #ifdef WITH_CPYCHECKER_SETS_EXCEPTION_ATTRIBUTE
42 #define CPYCHECKER_SETS_EXCEPTION __attribute__ ((cpychecker_sets_exception))
43 #else
44 #define CPYCHECKER_SETS_EXCEPTION
45 #endif
46
47 #ifdef WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE
48 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION               \
49   __attribute__ ((cpychecker_negative_result_sets_exception))
50 #else
51 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
52 #endif
53
54 /* /usr/include/features.h on linux systems will define _POSIX_C_SOURCE
55    if it sees _GNU_SOURCE (which config.h will define).
56    pyconfig.h defines _POSIX_C_SOURCE to a different value than
57    /usr/include/features.h does causing compilation to fail.
58    To work around this, undef _POSIX_C_SOURCE before we include Python.h.
59
60    Same problem with _XOPEN_SOURCE.  */
61 #undef _POSIX_C_SOURCE
62 #undef _XOPEN_SOURCE
63
64 /* On sparc-solaris, /usr/include/sys/feature_tests.h defines
65    _FILE_OFFSET_BITS, which pyconfig.h also defines.  Same work
66    around technique as above.  */
67 #undef _FILE_OFFSET_BITS
68
69 /* A kludge to avoid redefinition of snprintf on Windows by pyerrors.h.  */
70 #if defined(_WIN32) && defined(HAVE_DECL_SNPRINTF)
71 #define HAVE_SNPRINTF 1
72 #endif
73
74 /* Another kludge to avoid compilation errors because MinGW defines
75    'hypot' to '_hypot', but the C++ headers says "using ::hypot".  */
76 #ifdef __MINGW32__
77 # define _hypot hypot
78 #endif
79
80 /* Request clean size types from Python.  */
81 #define PY_SSIZE_T_CLEAN
82
83 /* Include the Python header files using angle brackets rather than
84    double quotes.  On case-insensitive filesystems, this prevents us
85    from including our python/python.h header file.  */
86 #include <Python.h>
87 #include <frameobject.h>
88 #include "py-ref.h"
89
90 #if PY_MAJOR_VERSION >= 3
91 #define IS_PY3K 1
92 #endif
93
94 #ifdef IS_PY3K
95 #define Py_TPFLAGS_CHECKTYPES 0
96
97 #define PyInt_Check PyLong_Check
98 #define PyInt_AsLong PyLong_AsLong
99 #define PyInt_AsSsize_t PyLong_AsSsize_t
100
101 #define PyString_FromString PyUnicode_FromString
102 #define PyString_Decode PyUnicode_Decode
103 #define PyString_FromFormat PyUnicode_FromFormat
104 #define PyString_Check PyUnicode_Check
105 #endif
106
107 /* If Python.h does not define WITH_THREAD, then the various
108    GIL-related functions will not be defined.  However,
109    PyGILState_STATE will be.  */
110 #ifndef WITH_THREAD
111 #define PyGILState_Ensure() ((PyGILState_STATE) 0)
112 #define PyGILState_Release(ARG) ((void)(ARG))
113 #define PyEval_InitThreads()
114 #define PyThreadState_Swap(ARG) ((void)(ARG))
115 #define PyEval_ReleaseLock()
116 #endif
117
118 /* Python supplies HAVE_LONG_LONG and some `long long' support when it
119    is available.  These defines let us handle the differences more
120    cleanly.  */
121 #ifdef HAVE_LONG_LONG
122
123 #define GDB_PY_LL_ARG "L"
124 #define GDB_PY_LLU_ARG "K"
125 typedef PY_LONG_LONG gdb_py_longest;
126 typedef unsigned PY_LONG_LONG gdb_py_ulongest;
127 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLongLong
128
129 #else /* HAVE_LONG_LONG */
130
131 #define GDB_PY_LL_ARG "L"
132 #define GDB_PY_LLU_ARG "K"
133 typedef long gdb_py_longest;
134 typedef unsigned long gdb_py_ulongest;
135 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLong
136
137 #endif /* HAVE_LONG_LONG */
138
139 #if PY_VERSION_HEX < 0x03020000
140 typedef long Py_hash_t;
141 #endif
142
143 /* PyMem_RawMalloc appeared in Python 3.4.  For earlier versions, we can just
144    fall back to PyMem_Malloc.  */
145
146 #if PY_VERSION_HEX < 0x03040000
147 #define PyMem_RawMalloc PyMem_Malloc
148 #endif
149
150 /* Python 2.6 did not wrap Py_DECREF in 'do {...} while (0)', leading
151    to 'suggest explicit braces to avoid ambiguous ‘else’' gcc errors.
152    Wrap it ourselves, so that callers don't need to care.  */
153
154 static inline void
155 gdb_Py_DECREF (void *op) /* ARI: editCase function */
156 {
157   Py_DECREF (op);
158 }
159
160 #undef Py_DECREF
161 #define Py_DECREF(op) gdb_Py_DECREF (op)
162
163 /* PyObject_CallMethod's 'method' and 'format' parameters were missing
164    the 'const' qualifier before Python 3.4.  Hence, we wrap the
165    function in our own version to avoid errors with string literals.
166    Note, this is a variadic template because PyObject_CallMethod is a
167    varargs function and Python doesn't have a "PyObject_VaCallMethod"
168    variant taking a va_list that we could defer to instead.  */
169
170 template<typename... Args>
171 static inline PyObject *
172 gdb_PyObject_CallMethod (PyObject *o, const char *method, const char *format,
173                          Args... args) /* ARI: editCase function */
174 {
175   return PyObject_CallMethod (o,
176                               const_cast<char *> (method),
177                               const_cast<char *> (format),
178                               args...);
179 }
180
181 #undef PyObject_CallMethod
182 #define PyObject_CallMethod gdb_PyObject_CallMethod
183
184 /* The 'name' parameter of PyErr_NewException was missing the 'const'
185    qualifier in Python <= 3.4.  Hence, we wrap it in a function to
186    avoid errors when compiled with -Werror.  */
187
188 static inline PyObject*
189 gdb_PyErr_NewException (const char *name, PyObject *base, PyObject *dict)
190 {
191   return PyErr_NewException (const_cast<char *> (name), base, dict);
192 }
193
194 #define PyErr_NewException gdb_PyErr_NewException
195
196 /* PySys_GetObject's 'name' parameter was missing the 'const'
197    qualifier before Python 3.4.  Hence, we wrap it in a function to
198    avoid errors when compiled with -Werror.  */
199
200 static inline PyObject *
201 gdb_PySys_GetObject (const char *name)
202 {
203   return PySys_GetObject (const_cast<char *> (name));
204 }
205
206 #define PySys_GetObject gdb_PySys_GetObject
207
208 /* PySys_SetPath's 'path' parameter was missing the 'const' qualifier
209    before Python 3.6.  Hence, we wrap it in a function to avoid errors
210    when compiled with -Werror.  */
211
212 #ifdef IS_PY3K
213 # define GDB_PYSYS_SETPATH_CHAR wchar_t
214 #else
215 # define GDB_PYSYS_SETPATH_CHAR char
216 #endif
217
218 static inline void
219 gdb_PySys_SetPath (const GDB_PYSYS_SETPATH_CHAR *path)
220 {
221   PySys_SetPath (const_cast<GDB_PYSYS_SETPATH_CHAR *> (path));
222 }
223
224 #define PySys_SetPath gdb_PySys_SetPath
225
226 /* Wrap PyGetSetDef to allow convenient construction with string
227    literals.  Unfortunately, PyGetSetDef's 'name' and 'doc' members
228    are 'char *' instead of 'const char *', meaning that in order to
229    list-initialize PyGetSetDef arrays with string literals (and
230    without the wrapping below) would require writing explicit 'char *'
231    casts.  Instead, we extend PyGetSetDef and add constexpr
232    constructors that accept const 'name' and 'doc', hiding the ugly
233    casts here in a single place.  */
234
235 struct gdb_PyGetSetDef : PyGetSetDef
236 {
237   constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_,
238                              const char *doc_, void *closure_)
239     : PyGetSetDef {const_cast<char *> (name_), get_, set_,
240                    const_cast<char *> (doc_), closure_}
241   {}
242
243   /* Alternative constructor that allows omitting the closure in list
244      initialization.  */
245   constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_,
246                              const char *doc_)
247     : gdb_PyGetSetDef {name_, get_, set_, doc_, NULL}
248   {}
249
250   /* Constructor for the sentinel entries.  */
251   constexpr gdb_PyGetSetDef (std::nullptr_t)
252     : gdb_PyGetSetDef {NULL, NULL, NULL, NULL, NULL}
253   {}
254 };
255
256 /* The 'keywords' parameter of PyArg_ParseTupleAndKeywords has type
257    'char **'.  However, string literals are const in C++, and so to
258    avoid casting at every keyword array definition, we'll need to make
259    the keywords array an array of 'const char *'.  To avoid having all
260    callers add a 'const_cast<char **>' themselves when passing such an
261    array through 'char **', we define our own version of
262    PyArg_ParseTupleAndKeywords here with a corresponding 'keywords'
263    parameter type that does the cast in a single place.  (This is not
264    an overload of PyArg_ParseTupleAndKeywords in order to make it
265    clearer that we're calling our own function instead of a function
266    that exists in some newer Python version.)  */
267
268 static inline int
269 gdb_PyArg_ParseTupleAndKeywords (PyObject *args, PyObject *kw,
270                                  const char *format, const char **keywords, ...)
271 {
272   va_list ap;
273   int res;
274
275   va_start (ap, keywords);
276   res = PyArg_VaParseTupleAndKeywords (args, kw, format,
277                                        const_cast<char **> (keywords),
278                                        ap);
279   va_end (ap);
280
281   return res;
282 }
283
284 /* In order to be able to parse symtab_and_line_to_sal_object function
285    a real symtab_and_line structure is needed.  */
286 #include "symtab.h"
287
288 /* Also needed to parse enum var_types. */
289 #include "command.h"
290 #include "breakpoint.h"
291
292 enum gdbpy_iter_kind { iter_keys, iter_values, iter_items };
293
294 struct block;
295 struct value;
296 struct language_defn;
297 struct program_space;
298 struct bpstats;
299 struct inferior;
300
301 extern int gdb_python_initialized;
302
303 extern PyObject *gdb_module;
304 extern PyObject *gdb_python_module;
305 extern PyTypeObject value_object_type
306     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("value_object");
307 extern PyTypeObject block_object_type
308     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("block_object");
309 extern PyTypeObject symbol_object_type
310     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symbol_object");
311 extern PyTypeObject event_object_type
312     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
313 extern PyTypeObject breakpoint_object_type
314     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_object");
315 extern PyTypeObject frame_object_type
316     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("frame_object");
317 extern PyTypeObject thread_object_type
318     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("thread_object");
319
320 struct gdbpy_breakpoint_object
321 {
322   PyObject_HEAD
323
324   /* The breakpoint number according to gdb.  */
325   int number;
326
327   /* The gdb breakpoint object, or NULL if the breakpoint has been
328      deleted.  */
329   struct breakpoint *bp;
330
331   /* 1 is this is a FinishBreakpoint object, 0 otherwise.  */
332   int is_finish_bp;
333 };
334
335 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
336    exception if it is invalid.  */
337 #define BPPY_REQUIRE_VALID(Breakpoint)                                  \
338     do {                                                                \
339       if ((Breakpoint)->bp == NULL)                                     \
340         return PyErr_Format (PyExc_RuntimeError,                        \
341                              _("Breakpoint %d is invalid."),            \
342                              (Breakpoint)->number);                     \
343     } while (0)
344
345 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
346    exception if it is invalid.  This macro is for use in setter functions.  */
347 #define BPPY_SET_REQUIRE_VALID(Breakpoint)                              \
348     do {                                                                \
349       if ((Breakpoint)->bp == NULL)                                     \
350         {                                                               \
351           PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
352                         (Breakpoint)->number);                          \
353           return -1;                                                    \
354         }                                                               \
355     } while (0)
356
357
358 /* Variables used to pass information between the Breakpoint
359    constructor and the breakpoint-created hook function.  */
360 extern gdbpy_breakpoint_object *bppy_pending_object;
361
362
363 struct thread_object
364 {
365   PyObject_HEAD
366
367   /* The thread we represent.  */
368   struct thread_info *thread;
369
370   /* The Inferior object to which this thread belongs.  */
371   PyObject *inf_obj;
372 };
373
374 struct inferior_object;
375
376 extern struct cmd_list_element *set_python_list;
377 extern struct cmd_list_element *show_python_list;
378 \f
379 /* extension_language_script_ops "methods".  */
380
381 /* Return true if auto-loading Python scripts is enabled.
382    This is the extension_language_script_ops.auto_load_enabled "method".  */
383
384 extern bool gdbpy_auto_load_enabled (const struct extension_language_defn *);
385
386 /* extension_language_ops "methods".  */
387
388 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer
389   (const struct extension_language_defn *,
390    struct value *value,
391    struct ui_file *stream, int recurse,
392    const struct value_print_options *options,
393    const struct language_defn *language);
394 extern enum ext_lang_bt_status gdbpy_apply_frame_filter
395   (const struct extension_language_defn *,
396    struct frame_info *frame, frame_filter_flags flags,
397    enum ext_lang_frame_args args_type,
398    struct ui_out *out, int frame_low, int frame_high);
399 extern void gdbpy_preserve_values (const struct extension_language_defn *,
400                                    struct objfile *objfile,
401                                    htab_t copied_types);
402 extern enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop
403   (const struct extension_language_defn *, struct breakpoint *);
404 extern int gdbpy_breakpoint_has_cond (const struct extension_language_defn *,
405                                       struct breakpoint *b);
406
407 extern enum ext_lang_rc gdbpy_get_matching_xmethod_workers
408   (const struct extension_language_defn *extlang,
409    struct type *obj_type, const char *method_name,
410    std::vector<xmethod_worker_up> *dm_vec);
411
412 \f
413 PyObject *gdbpy_history (PyObject *self, PyObject *args);
414 PyObject *gdbpy_add_history (PyObject *self, PyObject *args);
415 PyObject *gdbpy_convenience_variable (PyObject *self, PyObject *args);
416 PyObject *gdbpy_set_convenience_variable (PyObject *self, PyObject *args);
417 PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
418 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
419 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw);
420 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args,
421                                       PyObject *kw);
422 PyObject *gdbpy_lookup_static_symbol (PyObject *self, PyObject *args,
423                                       PyObject *kw);
424 PyObject *gdbpy_lookup_static_symbols (PyObject *self, PyObject *args,
425                                            PyObject *kw);
426 PyObject *gdbpy_start_recording (PyObject *self, PyObject *args);
427 PyObject *gdbpy_current_recording (PyObject *self, PyObject *args);
428 PyObject *gdbpy_stop_recording (PyObject *self, PyObject *args);
429 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
430 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
431 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
432 int gdbpy_is_field (PyObject *obj);
433 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
434                                            const char *encoding,
435                                            struct type *type);
436 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
437 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
438 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
439 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
440 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
441 PyObject *gdbpy_parameter_value (const setting &var);
442 gdb::unique_xmalloc_ptr<char> gdbpy_parse_command_name
443   (const char *name, struct cmd_list_element ***base_list,
444    struct cmd_list_element **start_list);
445 PyObject *gdbpy_register_tui_window (PyObject *self, PyObject *args,
446                                      PyObject *kw);
447
448 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
449 PyObject *symtab_to_symtab_object (struct symtab *symtab);
450 PyObject *symbol_to_symbol_object (struct symbol *sym);
451 PyObject *block_to_block_object (const struct block *block,
452                                  struct objfile *objfile);
453 PyObject *value_to_value_object (struct value *v);
454 PyObject *value_to_value_object_no_release (struct value *v);
455 PyObject *type_to_type_object (struct type *);
456 PyObject *frame_info_to_frame_object (struct frame_info *frame);
457 PyObject *symtab_to_linetable_object (PyObject *symtab);
458 gdbpy_ref<> pspace_to_pspace_object (struct program_space *);
459 PyObject *pspy_get_printers (PyObject *, void *);
460 PyObject *pspy_get_frame_filters (PyObject *, void *);
461 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
462 PyObject *pspy_get_xmethods (PyObject *, void *);
463
464 gdbpy_ref<> objfile_to_objfile_object (struct objfile *);
465 PyObject *objfpy_get_printers (PyObject *, void *);
466 PyObject *objfpy_get_frame_filters (PyObject *, void *);
467 PyObject *objfpy_get_frame_unwinders (PyObject *, void *);
468 PyObject *objfpy_get_xmethods (PyObject *, void *);
469 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw);
470
471 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch);
472 PyObject *gdbpy_all_architecture_names (PyObject *self, PyObject *args);
473
474 PyObject *gdbpy_new_register_descriptor_iterator (struct gdbarch *gdbarch,
475                                                   const char *group_name);
476 PyObject *gdbpy_new_reggroup_iterator (struct gdbarch *gdbarch);
477
478 gdbpy_ref<thread_object> create_thread_object (struct thread_info *tp);
479 gdbpy_ref<> thread_to_thread_object (thread_info *thr);;
480 gdbpy_ref<inferior_object> inferior_to_inferior_object (inferior *inf);
481
482 PyObject *gdbpy_buffer_to_membuf (gdb::unique_xmalloc_ptr<gdb_byte> buffer,
483                                   CORE_ADDR address, ULONGEST length);
484
485 const struct block *block_object_to_block (PyObject *obj);
486 struct symbol *symbol_object_to_symbol (PyObject *obj);
487 struct value *value_object_to_value (PyObject *self);
488 struct value *convert_value_from_python (PyObject *obj);
489 struct type *type_object_to_type (PyObject *obj);
490 struct symtab *symtab_object_to_symtab (PyObject *obj);
491 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
492 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
493 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
494
495 void gdbpy_initialize_gdb_readline (void);
496 int gdbpy_initialize_auto_load (void)
497   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
498 int gdbpy_initialize_values (void)
499   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
500 int gdbpy_initialize_frames (void)
501   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
502 int gdbpy_initialize_instruction (void)
503   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
504 int gdbpy_initialize_btrace (void)
505   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
506 int gdbpy_initialize_record (void)
507   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
508 int gdbpy_initialize_symtabs (void)
509   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
510 int gdbpy_initialize_commands (void)
511   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
512 int gdbpy_initialize_symbols (void)
513   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
514 int gdbpy_initialize_symtabs (void)
515   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
516 int gdbpy_initialize_blocks (void)
517   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
518 int gdbpy_initialize_types (void)
519   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
520 int gdbpy_initialize_functions (void)
521   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
522 int gdbpy_initialize_pspace (void)
523   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
524 int gdbpy_initialize_objfile (void)
525   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
526 int gdbpy_initialize_breakpoints (void)
527   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
528 int gdbpy_initialize_finishbreakpoints (void)
529   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
530 int gdbpy_initialize_lazy_string (void)
531   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
532 int gdbpy_initialize_linetable (void)
533   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
534 int gdbpy_initialize_parameters (void)
535   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
536 int gdbpy_initialize_thread (void)
537   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
538 int gdbpy_initialize_inferior (void)
539   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
540 int gdbpy_initialize_eventregistry (void)
541   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
542 int gdbpy_initialize_event (void)
543   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
544 int gdbpy_initialize_py_events (void)
545   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
546 int gdbpy_initialize_arch (void)
547   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
548 int gdbpy_initialize_registers ()
549   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
550 int gdbpy_initialize_xmethods (void)
551   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
552 int gdbpy_initialize_unwind (void)
553   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
554 int gdbpy_initialize_tui ()
555   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
556 int gdbpy_initialize_membuf ()
557   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
558
559 /* A wrapper for PyErr_Fetch that handles reference counting for the
560    caller.  */
561 class gdbpy_err_fetch
562 {
563 public:
564
565   gdbpy_err_fetch ()
566   {
567     PyErr_Fetch (&m_error_type, &m_error_value, &m_error_traceback);
568   }
569
570   ~gdbpy_err_fetch ()
571   {
572     Py_XDECREF (m_error_type);
573     Py_XDECREF (m_error_value);
574     Py_XDECREF (m_error_traceback);
575   }
576
577   /* Call PyErr_Restore using the values stashed in this object.
578      After this call, this object is invalid and neither the to_string
579      nor restore methods may be used again.  */
580
581   void restore ()
582   {
583     PyErr_Restore (m_error_type, m_error_value, m_error_traceback);
584     m_error_type = nullptr;
585     m_error_value = nullptr;
586     m_error_traceback = nullptr;
587   }
588
589   /* Return the string representation of the exception represented by
590      this object.  If the result is NULL a python error occurred, the
591      caller must clear it.  */
592
593   gdb::unique_xmalloc_ptr<char> to_string () const;
594
595   /* Return the string representation of the type of the exception
596      represented by this object.  If the result is NULL a python error
597      occurred, the caller must clear it.  */
598
599   gdb::unique_xmalloc_ptr<char> type_to_string () const;
600
601   /* Return true if the stored type matches TYPE, false otherwise.  */
602
603   bool type_matches (PyObject *type) const
604   {
605     return PyErr_GivenExceptionMatches (m_error_type, type);
606   }
607
608 private:
609
610   PyObject *m_error_type, *m_error_value, *m_error_traceback;
611 };
612
613 /* Called before entering the Python interpreter to install the
614    current language and architecture to be used for Python values.
615    Also set the active extension language for GDB so that SIGINT's
616    are directed our way, and if necessary install the right SIGINT
617    handler.  */
618 class gdbpy_enter
619 {
620  public:
621
622   gdbpy_enter (struct gdbarch *gdbarch, const struct language_defn *language);
623
624   ~gdbpy_enter ();
625
626   DISABLE_COPY_AND_ASSIGN (gdbpy_enter);
627
628  private:
629
630   struct active_ext_lang_state *m_previous_active;
631   PyGILState_STATE m_state;
632   struct gdbarch *m_gdbarch;
633   const struct language_defn *m_language;
634
635   /* An optional is used here because we don't want to call
636      PyErr_Fetch too early.  */
637   gdb::optional<gdbpy_err_fetch> m_error;
638 };
639
640 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
641    make constructor delegation a little nicer.  */
642 class gdbpy_enter_varobj : public gdbpy_enter
643 {
644  public:
645
646   /* This is defined in varobj.c, where it can access varobj
647      internals.  */
648   gdbpy_enter_varobj (const struct varobj *var);
649
650 };
651
652 /* The opposite of gdb_enter: this releases the GIL around a region,
653    allowing other Python threads to run.  No Python APIs may be used
654    while this is active.  */
655 class gdbpy_allow_threads
656 {
657 public:
658
659   gdbpy_allow_threads ()
660     : m_save (PyEval_SaveThread ())
661   {
662     gdb_assert (m_save != nullptr);
663   }
664
665   ~gdbpy_allow_threads ()
666   {
667     PyEval_RestoreThread (m_save);
668   }
669
670   DISABLE_COPY_AND_ASSIGN (gdbpy_allow_threads);
671
672 private:
673
674   PyThreadState *m_save;
675 };
676
677 extern struct gdbarch *python_gdbarch;
678 extern const struct language_defn *python_language;
679
680 /* Use this after a TRY_EXCEPT to throw the appropriate Python
681    exception.  */
682 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
683   do {                                          \
684     if (Exception.reason < 0)                   \
685       {                                         \
686         gdbpy_convert_exception (Exception);    \
687         return NULL;                            \
688       }                                         \
689   } while (0)
690
691 /* Use this after a TRY_EXCEPT to throw the appropriate Python
692    exception.  This macro is for use inside setter functions.  */
693 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
694     do {                                                                \
695       if (Exception.reason < 0)                                         \
696         {                                                               \
697           gdbpy_convert_exception (Exception);                          \
698           return -1;                                                    \
699         }                                                               \
700     } while (0)
701
702 int gdbpy_print_python_errors_p (void);
703 void gdbpy_print_stack (void);
704 void gdbpy_print_stack_or_quit ();
705 void gdbpy_handle_exception () ATTRIBUTE_NORETURN;
706
707 gdbpy_ref<> python_string_to_unicode (PyObject *obj);
708 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
709 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
710 gdbpy_ref<> python_string_to_target_python_string (PyObject *obj);
711 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
712 gdbpy_ref<> host_string_to_python_string (const char *str);
713 int gdbpy_is_string (PyObject *obj);
714 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
715
716 int gdbpy_is_lazy_string (PyObject *result);
717 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
718                                 struct type **str_type,
719                                 long *length,
720                                 gdb::unique_xmalloc_ptr<char> *encoding);
721
722 int gdbpy_is_value_object (PyObject *obj);
723
724 /* Note that these are declared here, and not in python.h with the
725    other pretty-printer functions, because they refer to PyObject.  */
726 gdbpy_ref<> apply_varobj_pretty_printer (PyObject *print_obj,
727                                          struct value **replacement,
728                                          struct ui_file *stream);
729 gdbpy_ref<> gdbpy_get_varobj_pretty_printer (struct value *value);
730 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
731 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
732
733 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
734 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
735
736 extern PyObject *gdbpy_doc_cst;
737 extern PyObject *gdbpy_children_cst;
738 extern PyObject *gdbpy_to_string_cst;
739 extern PyObject *gdbpy_display_hint_cst;
740 extern PyObject *gdbpy_enabled_cst;
741 extern PyObject *gdbpy_value_cst;
742
743 /* Exception types.  */
744 extern PyObject *gdbpy_gdb_error;
745 extern PyObject *gdbpy_gdb_memory_error;
746 extern PyObject *gdbpy_gdberror_exc;
747
748 extern void gdbpy_convert_exception (const struct gdb_exception &)
749     CPYCHECKER_SETS_EXCEPTION;
750
751 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
752     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
753
754 gdbpy_ref<> gdb_py_object_from_longest (LONGEST l);
755 gdbpy_ref<> gdb_py_object_from_ulongest (ULONGEST l);
756 int gdb_py_int_as_long (PyObject *, long *);
757
758 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
759
760 int gdb_pymodule_addobject (PyObject *module, const char *name,
761                             PyObject *object)
762   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
763
764 struct varobj_iter;
765 struct varobj;
766 std::unique_ptr<varobj_iter> py_varobj_get_iterator (struct varobj *var,
767                                                      PyObject *printer);
768
769 /* Deleter for Py_buffer unique_ptr specialization.  */
770
771 struct Py_buffer_deleter
772 {
773   void operator() (Py_buffer *b) const
774   {
775     PyBuffer_Release (b);
776   }
777 };
778
779 /* A unique_ptr specialization for Py_buffer.  */
780 typedef std::unique_ptr<Py_buffer, Py_buffer_deleter> Py_buffer_up;
781
782 /* Parse a register number from PYO_REG_ID and place the register number
783    into *REG_NUM.  The register is a register for GDBARCH.
784
785    If a register is parsed successfully then *REG_NUM will have been
786    updated, and true is returned.  Otherwise the contents of *REG_NUM are
787    undefined, and false is returned.
788
789    The PYO_REG_ID object can be a string, the name of the register.  This
790    is the slowest approach as GDB has to map the name to a number for each
791    call.  Alternatively PYO_REG_ID can be an internal GDB register
792    number.  This is quick but should not be encouraged as this means
793    Python scripts are now dependent on GDB's internal register numbering.
794    Final PYO_REG_ID can be a gdb.RegisterDescriptor object, these objects
795    can be looked up by name once, and then cache the register number so
796    should be as quick as using a register number.  */
797
798 extern bool gdbpy_parse_register_id (struct gdbarch *gdbarch,
799                                      PyObject *pyo_reg_id, int *reg_num);
800
801 #endif /* PYTHON_PYTHON_INTERNAL_H */
This page took 0.0605830000000001 seconds and 2 git commands to generate.