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