gdb/python/python-internal.h

   1 /* Gdb/Python header for private use by Python module.
   2
   3    Copyright (C) 2008-2017 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 GDB_PYTHON_INTERNAL_H
  21 #define GDB_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.  */
  31
  32 #ifdef WITH_CPYCHECKER_RETURNS_BORROWED_REF_ATTRIBUTE
  33 #define CPYCHECKER_RETURNS_BORROWED_REF                 \
  34   __attribute__ ((cpychecker_returns_borrowed_ref))
  35 #else
  36 #define CPYCHECKER_RETURNS_BORROWED_REF
  37 #endif
  38
  39 #ifdef WITH_CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF_ATTRIBUTE
  40 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)         \
  41   __attribute__ ((cpychecker_type_object_for_typedef (ARG)))
  42 #else
  43 #define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
  44 #endif
  45
  46 #ifdef WITH_CPYCHECKER_STEALS_REFERENCE_TO_ARG_ATTRIBUTE
  47 #define CPYCHECKER_STEALS_REFERENCE_TO_ARG(n) \
  48    __attribute__ ((cpychecker_steals_reference_to_arg (n)))
  49 #else
  50 #define CPYCHECKER_STEALS_REFERENCE_TO_ARG(n)
  51 #endif
  52
  53 #ifdef WITH_CPYCHECKER_SETS_EXCEPTION_ATTRIBUTE
  54 #define CPYCHECKER_SETS_EXCEPTION __attribute__ ((cpychecker_sets_exception))
  55 #else
  56 #define CPYCHECKER_SETS_EXCEPTION
  57 #endif
  58
  59 #ifdef WITH_CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION_ATTRIBUTE
  60 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION               \
  61   __attribute__ ((cpychecker_negative_result_sets_exception))
  62 #else
  63 #define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
  64 #endif
  65
  66 /* Python 2.4 doesn't include stdint.h soon enough to get {u,}intptr_t
  67    needed by pyport.h.  */
  68 /* /usr/include/features.h on linux systems will define _POSIX_C_SOURCE
  69    if it sees _GNU_SOURCE (which config.h will define).
  70    pyconfig.h defines _POSIX_C_SOURCE to a different value than
  71    /usr/include/features.h does causing compilation to fail.
  72    To work around this, undef _POSIX_C_SOURCE before we include Python.h.
  73
  74    Same problem with _XOPEN_SOURCE.  */
  75 #undef _POSIX_C_SOURCE
  76 #undef _XOPEN_SOURCE
  77
  78 /* On sparc-solaris, /usr/include/sys/feature_tests.h defines
  79    _FILE_OFFSET_BITS, which pyconfig.h also defines.  Same work
  80    around technique as above.  */
  81 #undef _FILE_OFFSET_BITS
  82
  83 /* A kludge to avoid redefinition of snprintf on Windows by pyerrors.h.  */
  84 #if defined(_WIN32) && defined(HAVE_DECL_SNPRINTF)
  85 #define HAVE_SNPRINTF 1
  86 #endif
  87
  88 /* Request clean size types from Python.  */
  89 #define PY_SSIZE_T_CLEAN
  90
  91 /* Include the Python header files using angle brackets rather than
  92    double quotes.  On case-insensitive filesystems, this prevents us
  93    from including our python/python.h header file.  */
  94 #include <Python.h>
  95 #include <frameobject.h>
  96
  97 #if PY_MAJOR_VERSION >= 3
  98 #define IS_PY3K 1
  99 #endif
 100
 101 #ifdef IS_PY3K
 102 #define Py_TPFLAGS_HAVE_ITER 0
 103 #define Py_TPFLAGS_CHECKTYPES 0
 104
 105 #define PyInt_Check PyLong_Check
 106 #define PyInt_FromLong PyLong_FromLong
 107 #define PyInt_FromSsize_t PyLong_FromSsize_t
 108 #define PyInt_AsLong PyLong_AsLong
 109 #define PyInt_AsSsize_t PyLong_AsSsize_t
 110
 111 #define PyString_FromString PyUnicode_FromString
 112 #define PyString_Decode PyUnicode_Decode
 113 #define PyString_FromFormat PyUnicode_FromFormat
 114 #define PyString_Check PyUnicode_Check
 115 #endif
 116
 117 #if HAVE_LIBPYTHON2_4
 118 /* Py_ssize_t is not defined until 2.5.
 119    Logical type for Py_ssize_t is Py_intptr_t, but that fails in 64-bit
 120    compilation due to several apparent mistakes in python2.4 API, so we
 121    use 'int' instead.  */
 122 typedef int Py_ssize_t;
 123 #endif
 124
 125 #ifndef PyVarObject_HEAD_INIT
 126 /* Python 2.4 does not define PyVarObject_HEAD_INIT.  */
 127 #define PyVarObject_HEAD_INIT(type, size)       \
 128     PyObject_HEAD_INIT(type) size,
 129
 130 #endif
 131
 132 #ifndef Py_TYPE
 133 /* Python 2.4 does not define Py_TYPE.  */
 134 #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
 135 #endif
 136
 137 /* If Python.h does not define WITH_THREAD, then the various
 138    GIL-related functions will not be defined.  However,
 139    PyGILState_STATE will be.  */
 140 #ifndef WITH_THREAD
 141 #define PyGILState_Ensure() ((PyGILState_STATE) 0)
 142 #define PyGILState_Release(ARG) ((void)(ARG))
 143 #define PyEval_InitThreads()
 144 #define PyThreadState_Swap(ARG) ((void)(ARG))
 145 #define PyEval_ReleaseLock()
 146 #endif
 147
 148 /* Python supplies HAVE_LONG_LONG and some `long long' support when it
 149    is available.  These defines let us handle the differences more
 150    cleanly.  */
 151 #ifdef HAVE_LONG_LONG
 152
 153 #define GDB_PY_LL_ARG "L"
 154 #define GDB_PY_LLU_ARG "K"
 155 typedef PY_LONG_LONG gdb_py_longest;
 156 typedef unsigned PY_LONG_LONG gdb_py_ulongest;
 157 #define gdb_py_long_from_longest PyLong_FromLongLong
 158 #define gdb_py_long_from_ulongest PyLong_FromUnsignedLongLong
 159 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLongLong
 160
 161 #else /* HAVE_LONG_LONG */
 162
 163 #define GDB_PY_LL_ARG "L"
 164 #define GDB_PY_LLU_ARG "K"
 165 typedef long gdb_py_longest;
 166 typedef unsigned long gdb_py_ulongest;
 167 #define gdb_py_long_from_longest PyLong_FromLong
 168 #define gdb_py_long_from_ulongest PyLong_FromUnsignedLong
 169 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLong
 170
 171 #endif /* HAVE_LONG_LONG */
 172
 173 #if PY_VERSION_HEX < 0x03020000
 174 typedef long Py_hash_t;
 175 #endif
 176
 177 /* PyMem_RawMalloc appeared in Python 3.4.  For earlier versions, we can just
 178    fall back to PyMem_Malloc.  */
 179
 180 #if PY_VERSION_HEX < 0x03040000
 181 #define PyMem_RawMalloc PyMem_Malloc
 182 #endif
 183
 184 /* Python 2.6 did not wrap Py_DECREF in 'do {...} while (0)', leading
 185    to 'suggest explicit braces to avoid ambiguous ‘else’' gcc errors.
 186    Wrap it ourselves, so that callers don't need to care.  */
 187
 188 static inline void
 189 gdb_Py_DECREF (void *op) /* ARI: editCase function */
 190 {
 191   /* ... and Python 2.4 didn't cast OP to PyObject pointer on the
 192      '(op)->ob_refcnt' references within the macro.  Cast it ourselves
 193      too.  */
 194   Py_DECREF ((PyObject *) op);
 195 }
 196
 197 #undef Py_DECREF
 198 #define Py_DECREF(op) gdb_Py_DECREF (op)
 199
 200 /* The second argument to PyObject_GetAttrString was missing the 'const'
 201    qualifier in Python-2.4.  Hence, we wrap it in a function to avoid errors
 202    when compiled with -Werror.  */
 203
 204 static inline PyObject *
 205 gdb_PyObject_GetAttrString (PyObject *obj,
 206                             const char *attr) /* ARI: editCase function */
 207 {
 208   return PyObject_GetAttrString (obj, (char *) attr);
 209 }
 210
 211 #define PyObject_GetAttrString(obj, attr) gdb_PyObject_GetAttrString (obj, attr)
 212
 213 /* The second argument to PyObject_HasAttrString was also missing the 'const'
 214    qualifier in Python-2.4.  Hence, we wrap it also in a function to avoid
 215    errors when compiled with -Werror.  */
 216
 217 static inline int
 218 gdb_PyObject_HasAttrString (PyObject *obj,
 219                             const char *attr)  /* ARI: editCase function */
 220 {
 221   return PyObject_HasAttrString (obj, (char *) attr);
 222 }
 223
 224 #define PyObject_HasAttrString(obj, attr) gdb_PyObject_HasAttrString (obj, attr)
 225
 226 /* PyObject_CallMethod's 'method' and 'format' parameters were missing
 227    the 'const' qualifier before Python 3.4.  Hence, we wrap the
 228    function in our own version to avoid errors with string literals.
 229    Note, this is a variadic template because PyObject_CallMethod is a
 230    varargs function and Python doesn't have a "PyObject_VaCallMethod"
 231    variant taking a va_list that we could defer to instead.  */
 232
 233 template<typename... Args>
 234 static inline PyObject *
 235 gdb_PyObject_CallMethod (PyObject *o, const char *method, const char *format,
 236                          Args... args) /* ARI: editCase function */
 237 {
 238   return PyObject_CallMethod (o,
 239                               const_cast<char *> (method),
 240                               const_cast<char *> (format),
 241                               args...);
 242 }
 243
 244 #undef PyObject_CallMethod
 245 #define PyObject_CallMethod gdb_PyObject_CallMethod
 246
 247 /* The 'name' parameter of PyErr_NewException was missing the 'const'
 248    qualifier in Python <= 3.4.  Hence, we wrap it in a function to
 249    avoid errors when compiled with -Werror.  */
 250
 251 static inline PyObject*
 252 gdb_PyErr_NewException (const char *name, PyObject *base, PyObject *dict)
 253 {
 254   return PyErr_NewException (const_cast<char *> (name), base, dict);
 255 }
 256
 257 #define PyErr_NewException gdb_PyErr_NewException
 258
 259 /* PySys_GetObject's 'name' parameter was missing the 'const'
 260    qualifier before Python 3.4.  Hence, we wrap it in a function to
 261    avoid errors when compiled with -Werror.  */
 262
 263 static inline PyObject *
 264 gdb_PySys_GetObject (const char *name)
 265 {
 266   return PySys_GetObject (const_cast<char *> (name));
 267 }
 268
 269 #define PySys_GetObject gdb_PySys_GetObject
 270
 271 /* PySys_SetPath's 'path' parameter was missing the 'const' qualifier
 272    before Python 3.6.  Hence, we wrap it in a function to avoid errors
 273    when compiled with -Werror.  */
 274
 275 #ifdef IS_PY3K
 276 # define GDB_PYSYS_SETPATH_CHAR wchar_t
 277 #else
 278 # define GDB_PYSYS_SETPATH_CHAR char
 279 #endif
 280
 281 static inline void
 282 gdb_PySys_SetPath (const GDB_PYSYS_SETPATH_CHAR *path)
 283 {
 284   PySys_SetPath (const_cast<GDB_PYSYS_SETPATH_CHAR *> (path));
 285 }
 286
 287 #define PySys_SetPath gdb_PySys_SetPath
 288
 289 /* Wrap PyGetSetDef to allow convenient construction with string
 290    literals.  Unfortunately, PyGetSetDef's 'name' and 'doc' members
 291    are 'char *' instead of 'const char *', meaning that in order to
 292    list-initialize PyGetSetDef arrays with string literals (and
 293    without the wrapping below) would require writing explicit 'char *'
 294    casts.  Instead, we extend PyGetSetDef and add constexpr
 295    constructors that accept const 'name' and 'doc', hiding the ugly
 296    casts here in a single place.  */
 297
 298 struct gdb_PyGetSetDef : PyGetSetDef
 299 {
 300   constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_,
 301                              const char *doc_, void *closure_)
 302     : PyGetSetDef {const_cast<char *> (name_), get_, set_,
 303                    const_cast<char *> (doc_), closure_}
 304   {}
 305
 306   /* Alternative constructor that allows omitting the closure in list
 307      initialization.  */
 308   constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_,
 309                              const char *doc_)
 310     : gdb_PyGetSetDef {name_, get_, set_, doc_, NULL}
 311   {}
 312
 313   /* Constructor for the sentinel entries.  */
 314   constexpr gdb_PyGetSetDef (std::nullptr_t)
 315     : gdb_PyGetSetDef {NULL, NULL, NULL, NULL, NULL}
 316   {}
 317 };
 318
 319 /* In order to be able to parse symtab_and_line_to_sal_object function
 320    a real symtab_and_line structure is needed.  */
 321 #include "symtab.h"
 322
 323 /* Also needed to parse enum var_types. */
 324 #include "command.h"
 325 #include "breakpoint.h"
 326
 327 enum gdbpy_iter_kind { iter_keys, iter_values, iter_items };
 328
 329 struct block;
 330 struct value;
 331 struct language_defn;
 332 struct program_space;
 333 struct bpstats;
 334 struct inferior;
 335
 336 extern int gdb_python_initialized;
 337
 338 extern PyObject *gdb_module;
 339 extern PyObject *gdb_python_module;
 340 extern PyTypeObject value_object_type
 341     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("value_object");
 342 extern PyTypeObject block_object_type
 343     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("block_object");
 344 extern PyTypeObject symbol_object_type
 345     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symbol_object");
 346 extern PyTypeObject event_object_type
 347     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
 348 extern PyTypeObject stop_event_object_type
 349     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
 350 extern PyTypeObject breakpoint_object_type
 351     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_object");
 352 extern PyTypeObject frame_object_type
 353     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("frame_object");
 354
 355 typedef struct gdbpy_breakpoint_object
 356 {
 357   PyObject_HEAD
 358
 359   /* The breakpoint number according to gdb.  */
 360   int number;
 361
 362   /* The gdb breakpoint object, or NULL if the breakpoint has been
 363      deleted.  */
 364   struct breakpoint *bp;
 365
 366   /* 1 is this is a FinishBreakpoint object, 0 otherwise.  */
 367   int is_finish_bp;
 368 } gdbpy_breakpoint_object;
 369
 370 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 371    exception if it is invalid.  */
 372 #define BPPY_REQUIRE_VALID(Breakpoint)                                  \
 373     do {                                                                \
 374       if ((Breakpoint)->bp == NULL)                                     \
 375         return PyErr_Format (PyExc_RuntimeError,                        \
 376                              _("Breakpoint %d is invalid."),            \
 377                              (Breakpoint)->number);                     \
 378     } while (0)
 379
 380 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 381    exception if it is invalid.  This macro is for use in setter functions.  */
 382 #define BPPY_SET_REQUIRE_VALID(Breakpoint)                              \
 383     do {                                                                \
 384       if ((Breakpoint)->bp == NULL)                                     \
 385         {                                                               \
 386           PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
 387                         (Breakpoint)->number);                          \
 388           return -1;                                                    \
 389         }                                                               \
 390     } while (0)
 391
 392
 393 /* Variables used to pass information between the Breakpoint
 394    constructor and the breakpoint-created hook function.  */
 395 extern gdbpy_breakpoint_object *bppy_pending_object;
 396
 397
 398 typedef struct
 399 {
 400   PyObject_HEAD
 401
 402   /* The thread we represent.  */
 403   struct thread_info *thread;
 404
 405   /* The Inferior object to which this thread belongs.  */
 406   PyObject *inf_obj;
 407 } thread_object;
 408
 409 extern struct cmd_list_element *set_python_list;
 410 extern struct cmd_list_element *show_python_list;
 411 \f
 412 /* extension_language_script_ops "methods".  */
 413
 414 extern int gdbpy_auto_load_enabled (const struct extension_language_defn *);
 415
 416 /* extension_language_ops "methods".  */
 417
 418 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer
 419   (const struct extension_language_defn *,
 420    struct type *type,
 421    LONGEST embedded_offset, CORE_ADDR address,
 422    struct ui_file *stream, int recurse,
 423    struct value *val,
 424    const struct value_print_options *options,
 425    const struct language_defn *language);
 426 extern enum ext_lang_bt_status gdbpy_apply_frame_filter
 427   (const struct extension_language_defn *,
 428    struct frame_info *frame, int flags, enum ext_lang_frame_args args_type,
 429    struct ui_out *out, int frame_low, int frame_high);
 430 extern void gdbpy_preserve_values (const struct extension_language_defn *,
 431                                    struct objfile *objfile,
 432                                    htab_t copied_types);
 433 extern enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop
 434   (const struct extension_language_defn *, struct breakpoint *);
 435 extern int gdbpy_breakpoint_has_cond (const struct extension_language_defn *,
 436                                       struct breakpoint *b);
 437
 438 extern void *gdbpy_clone_xmethod_worker_data
 439   (const struct extension_language_defn *extlang, void *data);
 440 extern void gdbpy_free_xmethod_worker_data
 441   (const struct extension_language_defn *extlang, void *data);
 442 extern enum ext_lang_rc gdbpy_get_matching_xmethod_workers
 443   (const struct extension_language_defn *extlang,
 444    struct type *obj_type, const char *method_name,
 445    xmethod_worker_vec **dm_vec);
 446 extern enum ext_lang_rc gdbpy_get_xmethod_arg_types
 447   (const struct extension_language_defn *extlang,
 448    struct xmethod_worker *worker,
 449    int *nargs,
 450    struct type ***arg_types);
 451 extern enum ext_lang_rc gdbpy_get_xmethod_result_type
 452   (const struct extension_language_defn *extlang,
 453    struct xmethod_worker *worker,
 454    struct value *object, struct value **args, int nargs,
 455    struct type **result_type);
 456 extern struct value *gdbpy_invoke_xmethod
 457   (const struct extension_language_defn *extlang,
 458    struct xmethod_worker *worker,
 459    struct value *obj, struct value **args, int nargs);
 460 \f
 461 PyObject *gdbpy_history (PyObject *self, PyObject *args);
 462 PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
 463 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
 464 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw);
 465 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args,
 466                                       PyObject *kw);
 467 PyObject *gdbpy_start_recording (PyObject *self, PyObject *args);
 468 PyObject *gdbpy_current_recording (PyObject *self, PyObject *args);
 469 PyObject *gdbpy_stop_recording (PyObject *self, PyObject *args);
 470 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
 471 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
 472 PyObject *gdbpy_block_for_pc (PyObject *self, PyObject *args);
 473 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
 474 int gdbpy_is_field (PyObject *obj);
 475 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 476                                            const char *encoding,
 477                                            struct type *type);
 478 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
 479 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
 480 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
 481 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
 482 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
 483 PyObject *gdbpy_parameter_value (enum var_types type, void *var);
 484 char *gdbpy_parse_command_name (const char *name,
 485                                 struct cmd_list_element ***base_list,
 486                                 struct cmd_list_element **start_list);
 487
 488 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
 489 PyObject *symtab_to_symtab_object (struct symtab *symtab);
 490 PyObject *symbol_to_symbol_object (struct symbol *sym);
 491 PyObject *block_to_block_object (const struct block *block,
 492                                  struct objfile *objfile);
 493 PyObject *value_to_value_object (struct value *v);
 494 PyObject *type_to_type_object (struct type *);
 495 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 496 PyObject *symtab_to_linetable_object (PyObject *symtab);
 497 PyObject *pspace_to_pspace_object (struct program_space *)
 498     CPYCHECKER_RETURNS_BORROWED_REF;
 499 PyObject *pspy_get_printers (PyObject *, void *);
 500 PyObject *pspy_get_frame_filters (PyObject *, void *);
 501 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
 502 PyObject *pspy_get_xmethods (PyObject *, void *);
 503
 504 PyObject *objfile_to_objfile_object (struct objfile *)
 505     CPYCHECKER_RETURNS_BORROWED_REF;
 506 PyObject *objfpy_get_printers (PyObject *, void *);
 507 PyObject *objfpy_get_frame_filters (PyObject *, void *);
 508 PyObject *objfpy_get_frame_unwinders (PyObject *, void *);
 509 PyObject *objfpy_get_xmethods (PyObject *, void *);
 510 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw);
 511
 512 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch);
 513
 514 thread_object *create_thread_object (struct thread_info *tp);
 515 thread_object *find_thread_object (ptid_t ptid)
 516     CPYCHECKER_RETURNS_BORROWED_REF;
 517 PyObject *find_inferior_object (int pid);
 518 PyObject *inferior_to_inferior_object (struct inferior *inferior);
 519
 520 const struct block *block_object_to_block (PyObject *obj);
 521 struct symbol *symbol_object_to_symbol (PyObject *obj);
 522 struct value *value_object_to_value (PyObject *self);
 523 struct value *convert_value_from_python (PyObject *obj);
 524 struct type *type_object_to_type (PyObject *obj);
 525 struct symtab *symtab_object_to_symtab (PyObject *obj);
 526 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
 527 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 528 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 529
 530 void gdbpy_initialize_gdb_readline (void);
 531 int gdbpy_initialize_auto_load (void)
 532   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 533 int gdbpy_initialize_values (void)
 534   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 535 int gdbpy_initialize_frames (void)
 536   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 537 int gdbpy_initialize_btrace (void)
 538   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 539 int gdbpy_initialize_record (void)
 540   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 541 int gdbpy_initialize_symtabs (void)
 542   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 543 int gdbpy_initialize_commands (void)
 544   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 545 int gdbpy_initialize_symbols (void)
 546   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 547 int gdbpy_initialize_symtabs (void)
 548   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 549 int gdbpy_initialize_blocks (void)
 550   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 551 int gdbpy_initialize_types (void)
 552   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 553 int gdbpy_initialize_functions (void)
 554   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 555 int gdbpy_initialize_pspace (void)
 556   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 557 int gdbpy_initialize_objfile (void)
 558   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 559 int gdbpy_initialize_breakpoints (void)
 560   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 561 int gdbpy_initialize_finishbreakpoints (void)
 562   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 563 int gdbpy_initialize_lazy_string (void)
 564   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 565 int gdbpy_initialize_linetable (void)
 566   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 567 int gdbpy_initialize_parameters (void)
 568   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 569 int gdbpy_initialize_thread (void)
 570   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 571 int gdbpy_initialize_inferior (void)
 572   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 573 int gdbpy_initialize_eventregistry (void)
 574   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 575 int gdbpy_initialize_event (void)
 576   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 577 int gdbpy_initialize_py_events (void)
 578   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 579 int gdbpy_initialize_stop_event (void)
 580   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 581 int gdbpy_initialize_signal_event (void)
 582   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 583 int gdbpy_initialize_breakpoint_event (void)
 584   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 585 int gdbpy_initialize_continue_event (void)
 586   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 587 int gdbpy_initialize_inferior_call_pre_event (void)
 588   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 589 int gdbpy_initialize_inferior_call_post_event (void)
 590   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 591 int gdbpy_initialize_register_changed_event (void)
 592   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 593 int gdbpy_initialize_memory_changed_event (void)
 594   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 595 int gdbpy_initialize_exited_event (void)
 596   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 597 int gdbpy_initialize_thread_event (void)
 598   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 599 int gdbpy_initialize_new_objfile_event (void)
 600   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 601 int gdbpy_initialize_clear_objfiles_event (void)
 602   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 603 int gdbpy_initialize_arch (void)
 604   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 605 int gdbpy_initialize_xmethods (void)
 606   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 607 int gdbpy_initialize_unwind (void)
 608   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 609
 610 /* Called before entering the Python interpreter to install the
 611    current language and architecture to be used for Python values.
 612    Also set the active extension language for GDB so that SIGINT's
 613    are directed our way, and if necessary install the right SIGINT
 614    handler.  */
 615 class gdbpy_enter
 616 {
 617  public:
 618
 619   gdbpy_enter (struct gdbarch *gdbarch, const struct language_defn *language);
 620
 621   ~gdbpy_enter ();
 622
 623   gdbpy_enter (const gdbpy_enter &) = delete;
 624   gdbpy_enter &operator= (const gdbpy_enter &) = delete;
 625
 626  private:
 627
 628   struct active_ext_lang_state *m_previous_active;
 629   PyGILState_STATE m_state;
 630   struct gdbarch *m_gdbarch;
 631   const struct language_defn *m_language;
 632   PyObject *m_error_type, *m_error_value, *m_error_traceback;
 633 };
 634
 635 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
 636    make constructor delegation a little nicer.  */
 637 class gdbpy_enter_varobj : public gdbpy_enter
 638 {
 639  public:
 640
 641   /* This is defined in varobj.c, where it can access varobj
 642      internals.  */
 643   gdbpy_enter_varobj (const struct varobj *var);
 644
 645 };
 646
 647 extern struct gdbarch *python_gdbarch;
 648 extern const struct language_defn *python_language;
 649
 650 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 651    exception.  */
 652 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
 653   do {                                          \
 654     if (Exception.reason < 0)                   \
 655       {                                         \
 656         gdbpy_convert_exception (Exception);    \
 657         return NULL;                            \
 658       }                                         \
 659   } while (0)
 660
 661 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 662    exception.  This macro is for use inside setter functions.  */
 663 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
 664     do {                                                                \
 665       if (Exception.reason < 0)                                         \
 666         {                                                               \
 667           gdbpy_convert_exception (Exception);                          \
 668           return -1;                                                    \
 669         }                                                               \
 670     } while (0)
 671
 672 int gdbpy_print_python_errors_p (void);
 673 void gdbpy_print_stack (void);
 674
 675 PyObject *python_string_to_unicode (PyObject *obj);
 676 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
 677 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
 678 PyObject *python_string_to_target_python_string (PyObject *obj);
 679 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
 680 PyObject *host_string_to_python_string (const char *str);
 681 int gdbpy_is_string (PyObject *obj);
 682 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
 683 gdb::unique_xmalloc_ptr<char> gdbpy_exception_to_string (PyObject *ptype,
 684                                                          PyObject *pvalue);
 685
 686 int gdbpy_is_lazy_string (PyObject *result);
 687 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 688                                 struct type **str_type,
 689                                 long *length,
 690                                 gdb::unique_xmalloc_ptr<char> *encoding);
 691
 692 int gdbpy_is_value_object (PyObject *obj);
 693
 694 /* Note that these are declared here, and not in python.h with the
 695    other pretty-printer functions, because they refer to PyObject.  */
 696 PyObject *apply_varobj_pretty_printer (PyObject *print_obj,
 697                                        struct value **replacement,
 698                                        struct ui_file *stream);
 699 PyObject *gdbpy_get_varobj_pretty_printer (struct value *value);
 700 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
 701 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
 702
 703 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 704 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 705
 706 extern PyObject *gdbpy_doc_cst;
 707 extern PyObject *gdbpy_children_cst;
 708 extern PyObject *gdbpy_to_string_cst;
 709 extern PyObject *gdbpy_display_hint_cst;
 710 extern PyObject *gdbpy_enabled_cst;
 711 extern PyObject *gdbpy_value_cst;
 712
 713 /* Exception types.  */
 714 extern PyObject *gdbpy_gdb_error;
 715 extern PyObject *gdbpy_gdb_memory_error;
 716 extern PyObject *gdbpy_gdberror_exc;
 717
 718 extern void gdbpy_convert_exception (struct gdb_exception)
 719     CPYCHECKER_SETS_EXCEPTION;
 720
 721 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 722     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 723
 724 PyObject *gdb_py_object_from_longest (LONGEST l);
 725 PyObject *gdb_py_object_from_ulongest (ULONGEST l);
 726 int gdb_py_int_as_long (PyObject *, long *);
 727
 728 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
 729
 730 int gdb_pymodule_addobject (PyObject *module, const char *name,
 731                             PyObject *object)
 732   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 733
 734 struct varobj_iter;
 735 struct varobj;
 736 struct varobj_iter *py_varobj_get_iterator (struct varobj *var,
 737                                             PyObject *printer);
 738
 739 #endif /* GDB_PYTHON_INTERNAL_H */