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_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
 496 int gdbpy_is_field (PyObject *obj);
 497 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 498                                            const char *encoding,
 499                                            struct type *type);
 500 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
 501 PyObject *gdbpy_create_ptid_object (ptid_t ptid);
 502 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
 503 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args);
 504 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
 505 PyObject *gdbpy_parameter_value (enum var_types type, void *var);
 506 char *gdbpy_parse_command_name (const char *name,
 507                                 struct cmd_list_element ***base_list,
 508                                 struct cmd_list_element **start_list);
 509
 510 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal);
 511 PyObject *symtab_to_symtab_object (struct symtab *symtab);
 512 PyObject *symbol_to_symbol_object (struct symbol *sym);
 513 PyObject *block_to_block_object (const struct block *block,
 514                                  struct objfile *objfile);
 515 PyObject *value_to_value_object (struct value *v);
 516 PyObject *type_to_type_object (struct type *);
 517 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 518 PyObject *symtab_to_linetable_object (PyObject *symtab);
 519 gdbpy_ref<> pspace_to_pspace_object (struct program_space *);
 520 PyObject *pspy_get_printers (PyObject *, void *);
 521 PyObject *pspy_get_frame_filters (PyObject *, void *);
 522 PyObject *pspy_get_frame_unwinders (PyObject *, void *);
 523 PyObject *pspy_get_xmethods (PyObject *, void *);
 524
 525 gdbpy_ref<> objfile_to_objfile_object (struct objfile *);
 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 *thread_to_thread_object (thread_info *thr)
 536   CPYCHECKER_RETURNS_BORROWED_REF;
 537 inferior_object *inferior_to_inferior_object (inferior *inf);
 538
 539 const struct block *block_object_to_block (PyObject *obj);
 540 struct symbol *symbol_object_to_symbol (PyObject *obj);
 541 struct value *value_object_to_value (PyObject *self);
 542 struct value *convert_value_from_python (PyObject *obj);
 543 struct type *type_object_to_type (PyObject *obj);
 544 struct symtab *symtab_object_to_symtab (PyObject *obj);
 545 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj);
 546 struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 547 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 548
 549 void gdbpy_initialize_gdb_readline (void);
 550 int gdbpy_initialize_auto_load (void)
 551   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 552 int gdbpy_initialize_values (void)
 553   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 554 int gdbpy_initialize_frames (void)
 555   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 556 int gdbpy_initialize_instruction (void)
 557   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 558 int gdbpy_initialize_btrace (void)
 559   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 560 int gdbpy_initialize_record (void)
 561   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 562 int gdbpy_initialize_symtabs (void)
 563   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 564 int gdbpy_initialize_commands (void)
 565   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 566 int gdbpy_initialize_symbols (void)
 567   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 568 int gdbpy_initialize_symtabs (void)
 569   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 570 int gdbpy_initialize_blocks (void)
 571   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 572 int gdbpy_initialize_types (void)
 573   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 574 int gdbpy_initialize_functions (void)
 575   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 576 int gdbpy_initialize_pspace (void)
 577   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 578 int gdbpy_initialize_objfile (void)
 579   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 580 int gdbpy_initialize_breakpoints (void)
 581   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 582 int gdbpy_initialize_finishbreakpoints (void)
 583   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 584 int gdbpy_initialize_lazy_string (void)
 585   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 586 int gdbpy_initialize_linetable (void)
 587   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 588 int gdbpy_initialize_parameters (void)
 589   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 590 int gdbpy_initialize_thread (void)
 591   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 592 int gdbpy_initialize_inferior (void)
 593   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 594 int gdbpy_initialize_eventregistry (void)
 595   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 596 int gdbpy_initialize_event (void)
 597   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 598 int gdbpy_initialize_py_events (void)
 599   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 600 int gdbpy_initialize_arch (void)
 601   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 602 int gdbpy_initialize_xmethods (void)
 603   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 604 int gdbpy_initialize_unwind (void)
 605   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 606
 607 /* Called before entering the Python interpreter to install the
 608    current language and architecture to be used for Python values.
 609    Also set the active extension language for GDB so that SIGINT's
 610    are directed our way, and if necessary install the right SIGINT
 611    handler.  */
 612 class gdbpy_enter
 613 {
 614  public:
 615
 616   gdbpy_enter (struct gdbarch *gdbarch, const struct language_defn *language);
 617
 618   ~gdbpy_enter ();
 619
 620   DISABLE_COPY_AND_ASSIGN (gdbpy_enter);
 621
 622  private:
 623
 624   struct active_ext_lang_state *m_previous_active;
 625   PyGILState_STATE m_state;
 626   struct gdbarch *m_gdbarch;
 627   const struct language_defn *m_language;
 628   PyObject *m_error_type, *m_error_value, *m_error_traceback;
 629 };
 630
 631 /* Like gdbpy_enter, but takes a varobj.  This is a subclass just to
 632    make constructor delegation a little nicer.  */
 633 class gdbpy_enter_varobj : public gdbpy_enter
 634 {
 635  public:
 636
 637   /* This is defined in varobj.c, where it can access varobj
 638      internals.  */
 639   gdbpy_enter_varobj (const struct varobj *var);
 640
 641 };
 642
 643 extern struct gdbarch *python_gdbarch;
 644 extern const struct language_defn *python_language;
 645
 646 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 647    exception.  */
 648 #define GDB_PY_HANDLE_EXCEPTION(Exception)      \
 649   do {                                          \
 650     if (Exception.reason < 0)                   \
 651       {                                         \
 652         gdbpy_convert_exception (Exception);    \
 653         return NULL;                            \
 654       }                                         \
 655   } while (0)
 656
 657 /* Use this after a TRY_EXCEPT to throw the appropriate Python
 658    exception.  This macro is for use inside setter functions.  */
 659 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception)                          \
 660     do {                                                                \
 661       if (Exception.reason < 0)                                         \
 662         {                                                               \
 663           gdbpy_convert_exception (Exception);                          \
 664           return -1;                                                    \
 665         }                                                               \
 666     } while (0)
 667
 668 int gdbpy_print_python_errors_p (void);
 669 void gdbpy_print_stack (void);
 670
 671 PyObject *python_string_to_unicode (PyObject *obj);
 672 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str);
 673 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj);
 674 PyObject *python_string_to_target_python_string (PyObject *obj);
 675 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj);
 676 PyObject *host_string_to_python_string (const char *str);
 677 int gdbpy_is_string (PyObject *obj);
 678 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj);
 679 gdb::unique_xmalloc_ptr<char> gdbpy_exception_to_string (PyObject *ptype,
 680                                                          PyObject *pvalue);
 681
 682 int gdbpy_is_lazy_string (PyObject *result);
 683 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 684                                 struct type **str_type,
 685                                 long *length,
 686                                 gdb::unique_xmalloc_ptr<char> *encoding);
 687
 688 int gdbpy_is_value_object (PyObject *obj);
 689
 690 /* Note that these are declared here, and not in python.h with the
 691    other pretty-printer functions, because they refer to PyObject.  */
 692 gdbpy_ref<> apply_varobj_pretty_printer (PyObject *print_obj,
 693                                          struct value **replacement,
 694                                          struct ui_file *stream);
 695 PyObject *gdbpy_get_varobj_pretty_printer (struct value *value);
 696 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer);
 697 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args);
 698
 699 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 700 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj);
 701
 702 extern PyObject *gdbpy_doc_cst;
 703 extern PyObject *gdbpy_children_cst;
 704 extern PyObject *gdbpy_to_string_cst;
 705 extern PyObject *gdbpy_display_hint_cst;
 706 extern PyObject *gdbpy_enabled_cst;
 707 extern PyObject *gdbpy_value_cst;
 708
 709 /* Exception types.  */
 710 extern PyObject *gdbpy_gdb_error;
 711 extern PyObject *gdbpy_gdb_memory_error;
 712 extern PyObject *gdbpy_gdberror_exc;
 713
 714 extern void gdbpy_convert_exception (struct gdb_exception)
 715     CPYCHECKER_SETS_EXCEPTION;
 716
 717 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 718     CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 719
 720 PyObject *gdb_py_object_from_longest (LONGEST l);
 721 PyObject *gdb_py_object_from_ulongest (ULONGEST l);
 722 int gdb_py_int_as_long (PyObject *, long *);
 723
 724 PyObject *gdb_py_generic_dict (PyObject *self, void *closure);
 725
 726 int gdb_pymodule_addobject (PyObject *module, const char *name,
 727                             PyObject *object)
 728   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 729
 730 struct varobj_iter;
 731 struct varobj;
 732 struct varobj_iter *py_varobj_get_iterator (struct varobj *var,
 733                                             PyObject *printer);
 734
 735 #endif /* GDB_PYTHON_INTERNAL_H */