gdb/python/python-internal.h

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