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