gdb/python/python-internal.h

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