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