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 /* 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 /* The 'keywords' parameter of PyArg_ParseTupleAndKeywords has type
 320    'char **'.  However, string literals are const in C++, and so to
 321    avoid casting at every keyword array definition, we'll need to make
 322    the keywords array an array of 'const char *'.  To avoid having all
 323    callers add a 'const_cast<char **>' themselves when passing such an
 324    array through 'char **', we define our own version of
 325    PyArg_ParseTupleAndKeywords here with a corresponding 'keywords'
 326    parameter type that does the cast in a single place.  (This is not
 327    an overload of PyArg_ParseTupleAndKeywords in order to make it
 328    clearer that we're calling our own function instead of a function
 329    that exists in some newer Python version.)  */
 330
 331 static inline int
 332 gdb_PyArg_ParseTupleAndKeywords (PyObject *args, PyObject *kw,
 333                                  const char *format, const char **keywords, ...)
 334 {
 335   va_list ap;
 336   int res;
 337
 338   va_start (ap, keywords);
 339   res = PyArg_VaParseTupleAndKeywords (args, kw, format,
 340                                        const_cast<char **> (keywords),
 341                                        ap);
 342   va_end (ap);
 343
 344   return res;
 345 }
 346
 347 /* In order to be able to parse symtab_and_line_to_sal_object function
 348    a real symtab_and_line structure is needed.  */
 349 #include "symtab.h"
 350
 351 /* Also needed to parse enum var_types. */
 352 #include "command.h"
 353 #include "breakpoint.h"
 354
 355 enum gdbpy_iter_kind { iter_keys, iter_values, iter_items };
 356
 357 struct block;
 358 struct value;
 359 struct language_defn;
 360 struct program_space;
 361 struct bpstats;
 362 struct inferior;
 363
 364 extern int gdb_python_initialized;
 365
 366 extern PyObject *gdb_module;
 367 extern PyObject *gdb_python_module;
 368 extern PyTypeObject value_object_type
 369     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("value_object");
 370 extern PyTypeObject block_object_type
 371     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("block_object");
 372 extern PyTypeObject symbol_object_type
 373     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symbol_object");
 374 extern PyTypeObject event_object_type
 375     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object");
 376 extern PyTypeObject breakpoint_object_type
 377     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_object");
 378 extern PyTypeObject frame_object_type
 379     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("frame_object");
 380 extern PyTypeObject thread_object_type
 381     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("thread_object");
 382
 383 typedef struct gdbpy_breakpoint_object
 384 {
 385   PyObject_HEAD
 386
 387   /* The breakpoint number according to gdb.  */
 388   int number;
 389
 390   /* The gdb breakpoint object, or NULL if the breakpoint has been
 391      deleted.  */
 392   struct breakpoint *bp;
 393
 394   /* 1 is this is a FinishBreakpoint object, 0 otherwise.  */
 395   int is_finish_bp;
 396 } gdbpy_breakpoint_object;
 397
 398 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 399    exception if it is invalid.  */
 400 #define BPPY_REQUIRE_VALID(Breakpoint)                                  \
 401     do {                                                                \
 402       if ((Breakpoint)->bp == NULL)                                     \
 403         return PyErr_Format (PyExc_RuntimeError,                        \
 404                              _("Breakpoint %d is invalid."),            \
 405                              (Breakpoint)->number);                     \
 406     } while (0)
 407
 408 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
 409    exception if it is invalid.  This macro is for use in setter functions.  */
 410 #define BPPY_SET_REQUIRE_VALID(Breakpoint)                              \
 411     do {                                                                \
 412       if ((Breakpoint)->bp == NULL)                                     \
 413         {                                                               \
 414           PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
 415                         (Breakpoint)->number);                          \
 416           return -1;                                                    \
 417         }                                                               \
 418     } while (0)
 419
 420
 421 /* Variables used to pass information between the Breakpoint
 422    constructor and the breakpoint-created hook function.  */
 423 extern gdbpy_breakpoint_object *bppy_pending_object;
 424
 425
 426 typedef struct
 427 {
 428   PyObject_HEAD
 429
 430   /* The thread we represent.  */
 431   struct thread_info *thread;
 432
 433   /* The Inferior object to which this thread belongs.  */
 434   PyObject *inf_obj;
 435 } thread_object;
 436
 437 extern struct cmd_list_element *set_python_list;
 438 extern struct cmd_list_element *show_python_list;
 439 \f
 440 /* extension_language_script_ops "methods".  */
 441
 442 extern int gdbpy_auto_load_enabled (const struct extension_language_defn *);
 443
 444 /* extension_language_ops "methods".  */
 445
 446 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer
 447   (const struct extension_language_defn *,
 448    struct type *type,
 449    LONGEST embedded_offset, CORE_ADDR address,
 450    struct ui_file *stream, int recurse,
 451    struct value *val,
 452    const struct value_print_options *options,
 453    const struct language_defn *language);
 454 extern enum ext_lang_bt_status gdbpy_apply_frame_filter
 455   (const struct extension_language_defn *,
 456    struct frame_info *frame, int flags, enum ext_lang_frame_args args_type,
 457    struct ui_out *out, int frame_low, int frame_high);
 458 extern void gdbpy_preserve_values (const struct extension_language_defn *,
 459                                    struct objfile *objfile,
 460                                    htab_t copied_types);
 461 extern enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop
 462   (const struct extension_language_defn *, struct breakpoint *);
 463 extern int gdbpy_breakpoint_has_cond (const struct extension_language_defn *,
 464                                       struct breakpoint *b);
 465
 466 extern enum ext_lang_rc gdbpy_get_matching_xmethod_workers
 467   (const struct extension_language_defn *extlang,
 468    struct type *obj_type, const char *method_name,
 469    std::vector<xmethod_worker_up> *dm_vec);
 470
 471 \f
 472 PyObject *gdbpy_history (PyObject *self, PyObject *args);
 473 PyObject *gdbpy_breakpoints (PyObject *, PyObject *);
 474 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *);
 475 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw);
 476 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args,
 477                                       PyObject *kw);
 478 PyObject *gdbpy_start_recording (PyObject *self, PyObject *args);
 479 PyObject *gdbpy_current_recording (PyObject *self, PyObject *args);
 480 PyObject *gdbpy_stop_recording (PyObject *self, PyObject *args);
 481 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
 482 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
 483 PyObject *gdbpy_block_for_pc (PyObject *self, PyObject *args);
 484 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
 485 int gdbpy_is_field (PyObject *obj);
 486 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 487                                            const char *encoding,
 488                                            struct type *type);
 489 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
 490 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
 491 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
 492 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
 493 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
 494 PyObject *gdbpy_parameter_value (enum var_types type, void *var);
 495 char *gdbpy_parse_command_name (const char *name,
 496                                 struct cmd_list_element ***base_list,
 497                                 struct cmd_list_element **start_list);
 498
 499 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
 500 PyObject *symtab_to_symtab_object (struct symtab *symtab);
 501 PyObject *symbol_to_symbol_object (struct symbol *sym);
 502 PyObject *block_to_block_object (const struct block *block,
 503                                  struct objfile *objfile);
 504 PyObject *value_to_value_object (struct value *v);
 505 PyObject *type_to_type_object (struct type *);
 506 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 507 PyObject *symtab_to_linetable_object (PyObject *symtab);
 508 PyObject *pspace_to_pspace_object (struct program_space *)
 509     CPYCHECKER_RETURNS_BORROWED_REF;
 510 PyObject *pspy_get_printers (PyObject *, void *);
 511 PyObject *pspy_get_frame_filters (PyObject *, void *);
 512 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
 513 PyObject *pspy_get_xmethods (PyObject *, void *);
 514
 515 PyObject *objfile_to_objfile_object (struct objfile *)
 516     CPYCHECKER_RETURNS_BORROWED_REF;
 517 PyObject *objfpy_get_printers (PyObject *, void *);
 518 PyObject *objfpy_get_frame_filters (PyObject *, void *);
 519 PyObject *objfpy_get_frame_unwinders (PyObject *, void *);
 520 PyObject *objfpy_get_xmethods (PyObject *, void *);
 521 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw);
 522
 523 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch);
 524
 525 thread_object *create_thread_object (struct thread_info *tp);
 526 thread_object *find_thread_object (ptid_t ptid)
 527     CPYCHECKER_RETURNS_BORROWED_REF;
 528 PyObject *find_inferior_object (int pid);
 529 PyObject *inferior_to_inferior_object (struct inferior *inferior);
 530
 531 const struct block *block_object_to_block (PyObject *obj);
 532 struct symbol *symbol_object_to_symbol (PyObject *obj);
 533 struct value *value_object_to_value (PyObject *self);
 534 struct value *convert_value_from_python (PyObject *obj);
 535 struct type *type_object_to_type (PyObject *obj);
 536 struct symtab *symtab_object_to_symtab (PyObject *obj);
 537 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
 538 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 539 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 540
 541 void gdbpy_initialize_gdb_readline (void);
 542 int gdbpy_initialize_auto_load (void)
 543   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 544 int gdbpy_initialize_values (void)
 545   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 546 int gdbpy_initialize_frames (void)
 547   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 548 int gdbpy_initialize_instruction (void)
 549   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 550 int gdbpy_initialize_btrace (void)
 551   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 552 int gdbpy_initialize_record (void)
 553   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 554 int gdbpy_initialize_symtabs (void)
 555   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 556 int gdbpy_initialize_commands (void)
 557   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 558 int gdbpy_initialize_symbols (void)
 559   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 560 int gdbpy_initialize_symtabs (void)
 561   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 562 int gdbpy_initialize_blocks (void)
 563   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 564 int gdbpy_initialize_types (void)
 565   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 566 int gdbpy_initialize_functions (void)
 567   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 568 int gdbpy_initialize_pspace (void)
 569   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 570 int gdbpy_initialize_objfile (void)
 571   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 572 int gdbpy_initialize_breakpoints (void)
 573   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 574 int gdbpy_initialize_finishbreakpoints (void)
 575   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 576 int gdbpy_initialize_lazy_string (void)
 577   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 578 int gdbpy_initialize_linetable (void)
 579   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 580 int gdbpy_initialize_parameters (void)
 581   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 582 int gdbpy_initialize_thread (void)
 583   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 584 int gdbpy_initialize_inferior (void)
 585   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 586 int gdbpy_initialize_eventregistry (void)
 587   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 588 int gdbpy_initialize_event (void)
 589   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 590 int gdbpy_initialize_py_events (void)
 591   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 592 int gdbpy_initialize_arch (void)
 593   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 594 int gdbpy_initialize_xmethods (void)
 595   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 596 int gdbpy_initialize_unwind (void)
 597   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 598
 599 /* Called before entering the Python interpreter to install the
 600    current language and architecture to be used for Python values.
 601    Also set the active extension language for GDB so that SIGINT's
 602    are directed our way, and if necessary install the right SIGINT
 603    handler.  */
 604 class gdbpy_enter
 605 {
 606  public:
 607
 608   gdbpy_enter (struct gdbarch *gdbarch, const struct language_defn *language);
 609
 610   ~gdbpy_enter ();
 611
 612   DISABLE_COPY_AND_ASSIGN (gdbpy_enter);
 613
 614  private:
 615
 616   struct active_ext_lang_state *m_previous_active;
 617   PyGILState_STATE m_state;
 618   struct gdbarch *m_gdbarch;
 619   const struct language_defn *m_language;
 620   PyObject *m_error_type, *m_error_value, *m_error_traceback;
 621 };
 622
 623 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
 624    make constructor delegation a little nicer.  */
 625 class gdbpy_enter_varobj : public gdbpy_enter
 626 {
 627  public:
 628
 629   /* This is defined in varobj.c, where it can access varobj
 630      internals.  */
 631   gdbpy_enter_varobj (const struct varobj *var);
 632
 633 };
 634
 635 extern struct gdbarch *python_gdbarch;
 636 extern const struct language_defn *python_language;
 637
 638 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 639    exception.  */
 640 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
 641   do {                                          \
 642     if (Exception.reason < 0)                   \
 643       {                                         \
 644         gdbpy_convert_exception (Exception);    \
 645         return NULL;                            \
 646       }                                         \
 647   } while (0)
 648
 649 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 650    exception.  This macro is for use inside setter functions.  */
 651 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
 652     do {                                                                \
 653       if (Exception.reason < 0)                                         \
 654         {                                                               \
 655           gdbpy_convert_exception (Exception);                          \
 656           return -1;                                                    \
 657         }                                                               \
 658     } while (0)
 659
 660 int gdbpy_print_python_errors_p (void);
 661 void gdbpy_print_stack (void);
 662
 663 PyObject *python_string_to_unicode (PyObject *obj);
 664 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
 665 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
 666 PyObject *python_string_to_target_python_string (PyObject *obj);
 667 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
 668 PyObject *host_string_to_python_string (const char *str);
 669 int gdbpy_is_string (PyObject *obj);
 670 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
 671 gdb::unique_xmalloc_ptr<char> gdbpy_exception_to_string (PyObject *ptype,
 672                                                          PyObject *pvalue);
 673
 674 int gdbpy_is_lazy_string (PyObject *result);
 675 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 676                                 struct type **str_type,
 677                                 long *length,
 678                                 gdb::unique_xmalloc_ptr<char> *encoding);
 679
 680 int gdbpy_is_value_object (PyObject *obj);
 681
 682 /* Note that these are declared here, and not in python.h with the
 683    other pretty-printer functions, because they refer to PyObject.  */
 684 PyObject *apply_varobj_pretty_printer (PyObject *print_obj,
 685                                        struct value **replacement,
 686                                        struct ui_file *stream);
 687 PyObject *gdbpy_get_varobj_pretty_printer (struct value *value);
 688 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
 689 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
 690
 691 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 692 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 693
 694 extern PyObject *gdbpy_doc_cst;
 695 extern PyObject *gdbpy_children_cst;
 696 extern PyObject *gdbpy_to_string_cst;
 697 extern PyObject *gdbpy_display_hint_cst;
 698 extern PyObject *gdbpy_enabled_cst;
 699 extern PyObject *gdbpy_value_cst;
 700
 701 /* Exception types.  */
 702 extern PyObject *gdbpy_gdb_error;
 703 extern PyObject *gdbpy_gdb_memory_error;
 704 extern PyObject *gdbpy_gdberror_exc;
 705
 706 extern void gdbpy_convert_exception (struct gdb_exception)
 707     CPYCHECKER_SETS_EXCEPTION;
 708
 709 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 710     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 711
 712 PyObject *gdb_py_object_from_longest (LONGEST l);
 713 PyObject *gdb_py_object_from_ulongest (ULONGEST l);
 714 int gdb_py_int_as_long (PyObject *, long *);
 715
 716 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
 717
 718 int gdb_pymodule_addobject (PyObject *module, const char *name,
 719                             PyObject *object)
 720   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 721
 722 struct varobj_iter;
 723 struct varobj;
 724 struct varobj_iter *py_varobj_get_iterator (struct varobj *var,
 725                                             PyObject *printer);
 726
 727 #endif /* GDB_PYTHON_INTERNAL_H */