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