gdb/python/python-internal.h

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