gdb/python/python-internal.h

   1 /* Gdb/Python header for private use by Python module.
   2
   3    Copyright (C) 2008-2022 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 bpstat;
 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 extern PyObject *gdbpy_history_count (PyObject *self, PyObject *args);
 416 PyObject *gdbpy_convenience_variable (PyObject *self, PyObject *args);
 417 PyObject *gdbpy_set_convenience_variable (PyObject *self, PyObject *args);
 418 PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
 419 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
 420 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw);
 421 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args,
 422                                       PyObject *kw);
 423 PyObject *gdbpy_lookup_static_symbol (PyObject *self, PyObject *args,
 424                                       PyObject *kw);
 425 PyObject *gdbpy_lookup_static_symbols (PyObject *self, PyObject *args,
 426                                            PyObject *kw);
 427 PyObject *gdbpy_start_recording (PyObject *self, PyObject *args);
 428 PyObject *gdbpy_current_recording (PyObject *self, PyObject *args);
 429 PyObject *gdbpy_stop_recording (PyObject *self, PyObject *args);
 430 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
 431 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
 432 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
 433 int gdbpy_is_field (PyObject *obj);
 434 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 435                                            const char *encoding,
 436                                            struct type *type);
 437 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
 438 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
 439 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
 440 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
 441 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
 442 PyObject *gdbpy_parameter_value (const setting &var);
 443 gdb::unique_xmalloc_ptr<char> gdbpy_parse_command_name
 444   (const char *name, struct cmd_list_element ***base_list,
 445    struct cmd_list_element **start_list);
 446 PyObject *gdbpy_register_tui_window (PyObject *self, PyObject *args,
 447                                      PyObject *kw);
 448
 449 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
 450 PyObject *symtab_to_symtab_object (struct symtab *symtab);
 451 PyObject *symbol_to_symbol_object (struct symbol *sym);
 452 PyObject *block_to_block_object (const struct block *block,
 453                                  struct objfile *objfile);
 454 PyObject *value_to_value_object (struct value *v);
 455 PyObject *value_to_value_object_no_release (struct value *v);
 456 PyObject *type_to_type_object (struct type *);
 457 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 458 PyObject *symtab_to_linetable_object (PyObject *symtab);
 459 gdbpy_ref<> pspace_to_pspace_object (struct program_space *);
 460 PyObject *pspy_get_printers (PyObject *, void *);
 461 PyObject *pspy_get_frame_filters (PyObject *, void *);
 462 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
 463 PyObject *pspy_get_xmethods (PyObject *, void *);
 464
 465 gdbpy_ref<> objfile_to_objfile_object (struct objfile *);
 466 PyObject *objfpy_get_printers (PyObject *, void *);
 467 PyObject *objfpy_get_frame_filters (PyObject *, void *);
 468 PyObject *objfpy_get_frame_unwinders (PyObject *, void *);
 469 PyObject *objfpy_get_xmethods (PyObject *, void *);
 470 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw);
 471
 472 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch);
 473 PyObject *gdbpy_all_architecture_names (PyObject *self, PyObject *args);
 474
 475 PyObject *gdbpy_new_register_descriptor_iterator (struct gdbarch *gdbarch,
 476                                                   const char *group_name);
 477 PyObject *gdbpy_new_reggroup_iterator (struct gdbarch *gdbarch);
 478
 479 gdbpy_ref<thread_object> create_thread_object (struct thread_info *tp);
 480 gdbpy_ref<> thread_to_thread_object (thread_info *thr);;
 481 gdbpy_ref<inferior_object> inferior_to_inferior_object (inferior *inf);
 482
 483 PyObject *gdbpy_buffer_to_membuf (gdb::unique_xmalloc_ptr<gdb_byte> buffer,
 484                                   CORE_ADDR address, ULONGEST length);
 485
 486 struct process_stratum_target;
 487 gdbpy_ref<> target_to_connection_object (process_stratum_target *target);
 488 PyObject *gdbpy_connections (PyObject *self, PyObject *args);
 489
 490 const struct block *block_object_to_block (PyObject *obj);
 491 struct symbol *symbol_object_to_symbol (PyObject *obj);
 492 struct value *value_object_to_value (PyObject *self);
 493 struct value *convert_value_from_python (PyObject *obj);
 494 struct type *type_object_to_type (PyObject *obj);
 495 struct symtab *symtab_object_to_symtab (PyObject *obj);
 496 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
 497 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 498 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 499
 500 void gdbpy_initialize_gdb_readline (void);
 501 int gdbpy_initialize_auto_load (void)
 502   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 503 int gdbpy_initialize_values (void)
 504   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 505 int gdbpy_initialize_frames (void)
 506   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 507 int gdbpy_initialize_instruction (void)
 508   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 509 int gdbpy_initialize_btrace (void)
 510   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 511 int gdbpy_initialize_record (void)
 512   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 513 int gdbpy_initialize_symtabs (void)
 514   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 515 int gdbpy_initialize_commands (void)
 516   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 517 int gdbpy_initialize_symbols (void)
 518   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 519 int gdbpy_initialize_symtabs (void)
 520   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 521 int gdbpy_initialize_blocks (void)
 522   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 523 int gdbpy_initialize_types (void)
 524   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 525 int gdbpy_initialize_functions (void)
 526   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 527 int gdbpy_initialize_pspace (void)
 528   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 529 int gdbpy_initialize_objfile (void)
 530   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 531 int gdbpy_initialize_breakpoints (void)
 532   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 533 int gdbpy_initialize_finishbreakpoints (void)
 534   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 535 int gdbpy_initialize_lazy_string (void)
 536   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 537 int gdbpy_initialize_linetable (void)
 538   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 539 int gdbpy_initialize_parameters (void)
 540   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 541 int gdbpy_initialize_thread (void)
 542   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 543 int gdbpy_initialize_inferior (void)
 544   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 545 int gdbpy_initialize_eventregistry (void)
 546   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 547 int gdbpy_initialize_event (void)
 548   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 549 int gdbpy_initialize_py_events (void)
 550   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 551 int gdbpy_initialize_arch (void)
 552   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 553 int gdbpy_initialize_registers ()
 554   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 555 int gdbpy_initialize_xmethods (void)
 556   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 557 int gdbpy_initialize_unwind (void)
 558   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 559 int gdbpy_initialize_tui ()
 560   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 561 int gdbpy_initialize_membuf ()
 562   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 563 int gdbpy_initialize_connection ()
 564   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 565
 566 /* A wrapper for PyErr_Fetch that handles reference counting for the
 567    caller.  */
 568 class gdbpy_err_fetch
 569 {
 570 public:
 571
 572   gdbpy_err_fetch ()
 573   {
 574     PyErr_Fetch (&m_error_type, &m_error_value, &m_error_traceback);
 575   }
 576
 577   ~gdbpy_err_fetch ()
 578   {
 579     Py_XDECREF (m_error_type);
 580     Py_XDECREF (m_error_value);
 581     Py_XDECREF (m_error_traceback);
 582   }
 583
 584   /* Call PyErr_Restore using the values stashed in this object.
 585      After this call, this object is invalid and neither the to_string
 586      nor restore methods may be used again.  */
 587
 588   void restore ()
 589   {
 590     PyErr_Restore (m_error_type, m_error_value, m_error_traceback);
 591     m_error_type = nullptr;
 592     m_error_value = nullptr;
 593     m_error_traceback = nullptr;
 594   }
 595
 596   /* Return the string representation of the exception represented by
 597      this object.  If the result is NULL a python error occurred, the
 598      caller must clear it.  */
 599
 600   gdb::unique_xmalloc_ptr<char> to_string () const;
 601
 602   /* Return the string representation of the type of the exception
 603      represented by this object.  If the result is NULL a python error
 604      occurred, the caller must clear it.  */
 605
 606   gdb::unique_xmalloc_ptr<char> type_to_string () const;
 607
 608   /* Return true if the stored type matches TYPE, false otherwise.  */
 609
 610   bool type_matches (PyObject *type) const
 611   {
 612     return PyErr_GivenExceptionMatches (m_error_type, type);
 613   }
 614
 615 private:
 616
 617   PyObject *m_error_type, *m_error_value, *m_error_traceback;
 618 };
 619
 620 /* Called before entering the Python interpreter to install the
 621    current language and architecture to be used for Python values.
 622    Also set the active extension language for GDB so that SIGINT's
 623    are directed our way, and if necessary install the right SIGINT
 624    handler.  */
 625 class gdbpy_enter
 626 {
 627  public:
 628
 629   /* Set the ambient Python architecture to GDBARCH and the language
 630      to LANGUAGE.  If GDBARCH is nullptr, then the architecture will
 631      be computed, when needed, using get_current_arch; see the
 632      get_gdbarch method.  If LANGUAGE is not nullptr, then the current
 633      language at time of construction will be saved (to be restored on
 634      destruction), and the current language will be set to
 635      LANGUAGE.  */
 636   explicit gdbpy_enter (struct gdbarch *gdbarch = nullptr,
 637                         const struct language_defn *language = nullptr);
 638
 639   ~gdbpy_enter ();
 640
 641   DISABLE_COPY_AND_ASSIGN (gdbpy_enter);
 642
 643   /* Return the current gdbarch, as known to the Python layer.  This
 644      is either python_gdbarch (which comes from the most recent call
 645      to the gdbpy_enter constructor), or, if that is nullptr, the
 646      result of get_current_arch.  */
 647   static struct gdbarch *get_gdbarch ();
 648
 649   /* Called only during gdb shutdown.  This sets python_gdbarch to an
 650      acceptable value.  */
 651   static void finalize ();
 652
 653  private:
 654
 655   /* The current gdbarch, according to Python.  This can be
 656      nullptr.  */
 657   static struct gdbarch *python_gdbarch;
 658
 659   struct active_ext_lang_state *m_previous_active;
 660   PyGILState_STATE m_state;
 661   struct gdbarch *m_gdbarch;
 662   const struct language_defn *m_language;
 663
 664   /* An optional is used here because we don't want to call
 665      PyErr_Fetch too early.  */
 666   gdb::optional<gdbpy_err_fetch> m_error;
 667 };
 668
 669 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
 670    make constructor delegation a little nicer.  */
 671 class gdbpy_enter_varobj : public gdbpy_enter
 672 {
 673  public:
 674
 675   /* This is defined in varobj.c, where it can access varobj
 676      internals.  */
 677   gdbpy_enter_varobj (const struct varobj *var);
 678
 679 };
 680
 681 /* The opposite of gdb_enter: this releases the GIL around a region,
 682    allowing other Python threads to run.  No Python APIs may be used
 683    while this is active.  */
 684 class gdbpy_allow_threads
 685 {
 686 public:
 687
 688   gdbpy_allow_threads ()
 689     : m_save (PyEval_SaveThread ())
 690   {
 691     gdb_assert (m_save != nullptr);
 692   }
 693
 694   ~gdbpy_allow_threads ()
 695   {
 696     PyEval_RestoreThread (m_save);
 697   }
 698
 699   DISABLE_COPY_AND_ASSIGN (gdbpy_allow_threads);
 700
 701 private:
 702
 703   PyThreadState *m_save;
 704 };
 705
 706 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 707    exception.  */
 708 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
 709   do {                                          \
 710     if (Exception.reason < 0)                   \
 711       {                                         \
 712         gdbpy_convert_exception (Exception);    \
 713         return NULL;                            \
 714       }                                         \
 715   } while (0)
 716
 717 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 718    exception.  This macro is for use inside setter functions.  */
 719 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
 720     do {                                                                \
 721       if (Exception.reason < 0)                                         \
 722         {                                                               \
 723           gdbpy_convert_exception (Exception);                          \
 724           return -1;                                                    \
 725         }                                                               \
 726     } while (0)
 727
 728 int gdbpy_print_python_errors_p (void);
 729 void gdbpy_print_stack (void);
 730 void gdbpy_print_stack_or_quit ();
 731 void gdbpy_handle_exception () ATTRIBUTE_NORETURN;
 732
 733 gdbpy_ref<> python_string_to_unicode (PyObject *obj);
 734 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
 735 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
 736 gdbpy_ref<> python_string_to_target_python_string (PyObject *obj);
 737 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
 738 gdbpy_ref<> host_string_to_python_string (const char *str);
 739 int gdbpy_is_string (PyObject *obj);
 740 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
 741
 742 int gdbpy_is_lazy_string (PyObject *result);
 743 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 744                                 struct type **str_type,
 745                                 long *length,
 746                                 gdb::unique_xmalloc_ptr<char> *encoding);
 747
 748 int gdbpy_is_value_object (PyObject *obj);
 749
 750 /* Note that these are declared here, and not in python.h with the
 751    other pretty-printer functions, because they refer to PyObject.  */
 752 gdbpy_ref<> apply_varobj_pretty_printer (PyObject *print_obj,
 753                                          struct value **replacement,
 754                                          struct ui_file *stream);
 755 gdbpy_ref<> gdbpy_get_varobj_pretty_printer (struct value *value);
 756 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
 757 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
 758
 759 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 760 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 761
 762 extern PyObject *gdbpy_doc_cst;
 763 extern PyObject *gdbpy_children_cst;
 764 extern PyObject *gdbpy_to_string_cst;
 765 extern PyObject *gdbpy_display_hint_cst;
 766 extern PyObject *gdbpy_enabled_cst;
 767 extern PyObject *gdbpy_value_cst;
 768
 769 /* Exception types.  */
 770 extern PyObject *gdbpy_gdb_error;
 771 extern PyObject *gdbpy_gdb_memory_error;
 772 extern PyObject *gdbpy_gdberror_exc;
 773
 774 extern void gdbpy_convert_exception (const struct gdb_exception &)
 775     CPYCHECKER_SETS_EXCEPTION;
 776
 777 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 778     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 779
 780 gdbpy_ref<> gdb_py_object_from_longest (LONGEST l);
 781 gdbpy_ref<> gdb_py_object_from_ulongest (ULONGEST l);
 782 int gdb_py_int_as_long (PyObject *, long *);
 783
 784 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
 785
 786 int gdb_pymodule_addobject (PyObject *module, const char *name,
 787                             PyObject *object)
 788   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 789
 790 struct varobj_iter;
 791 struct varobj;
 792 std::unique_ptr<varobj_iter> py_varobj_get_iterator (struct varobj *var,
 793                                                      PyObject *printer);
 794
 795 /* Deleter for Py_buffer unique_ptr specialization.  */
 796
 797 struct Py_buffer_deleter
 798 {
 799   void operator() (Py_buffer *b) const
 800   {
 801     PyBuffer_Release (b);
 802   }
 803 };
 804
 805 /* A unique_ptr specialization for Py_buffer.  */
 806 typedef std::unique_ptr<Py_buffer, Py_buffer_deleter> Py_buffer_up;
 807
 808 /* Parse a register number from PYO_REG_ID and place the register number
 809    into *REG_NUM.  The register is a register for GDBARCH.
 810
 811    If a register is parsed successfully then *REG_NUM will have been
 812    updated, and true is returned.  Otherwise the contents of *REG_NUM are
 813    undefined, and false is returned.
 814
 815    The PYO_REG_ID object can be a string, the name of the register.  This
 816    is the slowest approach as GDB has to map the name to a number for each
 817    call.  Alternatively PYO_REG_ID can be an internal GDB register
 818    number.  This is quick but should not be encouraged as this means
 819    Python scripts are now dependent on GDB's internal register numbering.
 820    Final PYO_REG_ID can be a gdb.RegisterDescriptor object, these objects
 821    can be looked up by name once, and then cache the register number so
 822    should be as quick as using a register number.  */
 823
 824 extern bool gdbpy_parse_register_id (struct gdbarch *gdbarch,
 825                                      PyObject *pyo_reg_id, int *reg_num);
 826
 827 #endif /* PYTHON_PYTHON_INTERNAL_H */