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