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