1 /* Gdb/Python header for private use by Python module. 2 3 Copyright (C) 2008-2023 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 #define Py_TPFLAGS_CHECKTYPES 0 91 92 /* If Python.h does not define WITH_THREAD, then the various 93 GIL-related functions will not be defined. However, 94 PyGILState_STATE will be. */ 95 #ifndef WITH_THREAD 96 #define PyGILState_Ensure() ((PyGILState_STATE) 0) 97 #define PyGILState_Release(ARG) ((void)(ARG)) 98 #define PyEval_InitThreads() 99 #define PyThreadState_Swap(ARG) ((void)(ARG)) 100 #define PyEval_ReleaseLock() 101 #endif 102 103 /* Python supplies HAVE_LONG_LONG and some `long long' support when it 104 is available. These defines let us handle the differences more 105 cleanly. */ 106 #ifdef HAVE_LONG_LONG 107 108 #define GDB_PY_LL_ARG "L" 109 #define GDB_PY_LLU_ARG "K" 110 typedef PY_LONG_LONG gdb_py_longest; 111 typedef unsigned PY_LONG_LONG gdb_py_ulongest; 112 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLongLong 113 114 #else /* HAVE_LONG_LONG */ 115 116 #define GDB_PY_LL_ARG "L" 117 #define GDB_PY_LLU_ARG "K" 118 typedef long gdb_py_longest; 119 typedef unsigned long gdb_py_ulongest; 120 #define gdb_py_long_as_ulongest PyLong_AsUnsignedLong 121 122 #endif /* HAVE_LONG_LONG */ 123 124 #if PY_VERSION_HEX < 0x03020000 125 typedef long Py_hash_t; 126 #endif 127 128 /* PyMem_RawMalloc appeared in Python 3.4. For earlier versions, we can just 129 fall back to PyMem_Malloc. */ 130 131 #if PY_VERSION_HEX < 0x03040000 132 #define PyMem_RawMalloc PyMem_Malloc 133 #endif 134 135 /* PyObject_CallMethod's 'method' and 'format' parameters were missing 136 the 'const' qualifier before Python 3.4. Hence, we wrap the 137 function in our own version to avoid errors with string literals. 138 Note, this is a variadic template because PyObject_CallMethod is a 139 varargs function and Python doesn't have a "PyObject_VaCallMethod" 140 variant taking a va_list that we could defer to instead. */ 141 142 template<typename... Args> 143 static inline PyObject * 144 gdb_PyObject_CallMethod (PyObject *o, const char *method, const char *format, 145 Args... args) /* ARI: editCase function */ 146 { 147 return PyObject_CallMethod (o, 148 const_cast<char *> (method), 149 const_cast<char *> (format), 150 args...); 151 } 152 153 #undef PyObject_CallMethod 154 #define PyObject_CallMethod gdb_PyObject_CallMethod 155 156 /* The 'name' parameter of PyErr_NewException was missing the 'const' 157 qualifier in Python <= 3.4. Hence, we wrap it in a function to 158 avoid errors when compiled with -Werror. */ 159 160 static inline PyObject* 161 gdb_PyErr_NewException (const char *name, PyObject *base, PyObject *dict) 162 { 163 return PyErr_NewException (const_cast<char *> (name), base, dict); 164 } 165 166 #define PyErr_NewException gdb_PyErr_NewException 167 168 /* PySys_GetObject's 'name' parameter was missing the 'const' 169 qualifier before Python 3.4. Hence, we wrap it in a function to 170 avoid errors when compiled with -Werror. */ 171 172 static inline PyObject * 173 gdb_PySys_GetObject (const char *name) 174 { 175 return PySys_GetObject (const_cast<char *> (name)); 176 } 177 178 #define PySys_GetObject gdb_PySys_GetObject 179 180 /* PySys_SetPath was deprecated in Python 3.11. Disable the deprecated 181 code for Python 3.10 and newer. */ 182 #if PY_VERSION_HEX < 0x030a0000 183 184 /* PySys_SetPath's 'path' parameter was missing the 'const' qualifier 185 before Python 3.6. Hence, we wrap it in a function to avoid errors 186 when compiled with -Werror. */ 187 188 # define GDB_PYSYS_SETPATH_CHAR wchar_t 189 190 static inline void 191 gdb_PySys_SetPath (const GDB_PYSYS_SETPATH_CHAR *path) 192 { 193 PySys_SetPath (const_cast<GDB_PYSYS_SETPATH_CHAR *> (path)); 194 } 195 196 #define PySys_SetPath gdb_PySys_SetPath 197 #endif 198 199 /* Wrap PyGetSetDef to allow convenient construction with string 200 literals. Unfortunately, PyGetSetDef's 'name' and 'doc' members 201 are 'char *' instead of 'const char *', meaning that in order to 202 list-initialize PyGetSetDef arrays with string literals (and 203 without the wrapping below) would require writing explicit 'char *' 204 casts. Instead, we extend PyGetSetDef and add constexpr 205 constructors that accept const 'name' and 'doc', hiding the ugly 206 casts here in a single place. */ 207 208 struct gdb_PyGetSetDef : PyGetSetDef 209 { 210 constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_, 211 const char *doc_, void *closure_) 212 : PyGetSetDef {const_cast<char *> (name_), get_, set_, 213 const_cast<char *> (doc_), closure_} 214 {} 215 216 /* Alternative constructor that allows omitting the closure in list 217 initialization. */ 218 constexpr gdb_PyGetSetDef (const char *name_, getter get_, setter set_, 219 const char *doc_) 220 : gdb_PyGetSetDef {name_, get_, set_, doc_, NULL} 221 {} 222 223 /* Constructor for the sentinel entries. */ 224 constexpr gdb_PyGetSetDef (std::nullptr_t) 225 : gdb_PyGetSetDef {NULL, NULL, NULL, NULL, NULL} 226 {} 227 }; 228 229 /* The 'keywords' parameter of PyArg_ParseTupleAndKeywords has type 230 'char **'. However, string literals are const in C++, and so to 231 avoid casting at every keyword array definition, we'll need to make 232 the keywords array an array of 'const char *'. To avoid having all 233 callers add a 'const_cast<char **>' themselves when passing such an 234 array through 'char **', we define our own version of 235 PyArg_ParseTupleAndKeywords here with a corresponding 'keywords' 236 parameter type that does the cast in a single place. (This is not 237 an overload of PyArg_ParseTupleAndKeywords in order to make it 238 clearer that we're calling our own function instead of a function 239 that exists in some newer Python version.) */ 240 241 static inline int 242 gdb_PyArg_ParseTupleAndKeywords (PyObject *args, PyObject *kw, 243 const char *format, const char **keywords, ...) 244 { 245 va_list ap; 246 int res; 247 248 va_start (ap, keywords); 249 res = PyArg_VaParseTupleAndKeywords (args, kw, format, 250 const_cast<char **> (keywords), 251 ap); 252 va_end (ap); 253 254 return res; 255 } 256 257 /* In order to be able to parse symtab_and_line_to_sal_object function 258 a real symtab_and_line structure is needed. */ 259 #include "symtab.h" 260 261 /* Also needed to parse enum var_types. */ 262 #include "command.h" 263 #include "breakpoint.h" 264 265 enum gdbpy_iter_kind { iter_keys, iter_values, iter_items }; 266 267 struct block; 268 struct value; 269 struct language_defn; 270 struct program_space; 271 struct bpstat; 272 struct inferior; 273 274 extern int gdb_python_initialized; 275 276 extern PyObject *gdb_module; 277 extern PyObject *gdb_python_module; 278 extern PyTypeObject value_object_type 279 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("value_object"); 280 extern PyTypeObject block_object_type 281 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("block_object"); 282 extern PyTypeObject symbol_object_type 283 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symbol_object"); 284 extern PyTypeObject event_object_type 285 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object"); 286 extern PyTypeObject breakpoint_object_type 287 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("breakpoint_object"); 288 extern PyTypeObject frame_object_type 289 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("frame_object"); 290 extern PyTypeObject thread_object_type 291 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("thread_object"); 292 293 /* Ensure that breakpoint_object_type is initialized and return true. If 294 breakpoint_object_type can't be initialized then set a suitable Python 295 error and return false. 296 297 This function needs to be called from any gdbpy_initialize_* function 298 that wants to reference breakpoint_object_type. After all the 299 gdbpy_initialize_* functions have been called then breakpoint_object_type 300 is guaranteed to have been initialized, and this function does not need 301 calling before referencing breakpoint_object_type. */ 302 303 extern bool gdbpy_breakpoint_init_breakpoint_type (); 304 305 struct gdbpy_breakpoint_object 306 { 307 PyObject_HEAD 308 309 /* The breakpoint number according to gdb. */ 310 int number; 311 312 /* The gdb breakpoint object, or NULL if the breakpoint has been 313 deleted. */ 314 struct breakpoint *bp; 315 316 /* 1 is this is a FinishBreakpoint object, 0 otherwise. */ 317 int is_finish_bp; 318 }; 319 320 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python 321 exception if it is invalid. */ 322 #define BPPY_REQUIRE_VALID(Breakpoint) \ 323 do { \ 324 if ((Breakpoint)->bp == NULL) \ 325 return PyErr_Format (PyExc_RuntimeError, \ 326 _("Breakpoint %d is invalid."), \ 327 (Breakpoint)->number); \ 328 } while (0) 329 330 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python 331 exception if it is invalid. This macro is for use in setter functions. */ 332 #define BPPY_SET_REQUIRE_VALID(Breakpoint) \ 333 do { \ 334 if ((Breakpoint)->bp == NULL) \ 335 { \ 336 PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \ 337 (Breakpoint)->number); \ 338 return -1; \ 339 } \ 340 } while (0) 341 342 343 /* Variables used to pass information between the Breakpoint 344 constructor and the breakpoint-created hook function. */ 345 extern gdbpy_breakpoint_object *bppy_pending_object; 346 347 348 struct thread_object 349 { 350 PyObject_HEAD 351 352 /* The thread we represent. */ 353 struct thread_info *thread; 354 355 /* The Inferior object to which this thread belongs. */ 356 PyObject *inf_obj; 357 }; 358 359 struct inferior_object; 360 361 extern struct cmd_list_element *set_python_list; 362 extern struct cmd_list_element *show_python_list; 363 364 /* extension_language_script_ops "methods". */ 365 366 /* Return true if auto-loading Python scripts is enabled. 367 This is the extension_language_script_ops.auto_load_enabled "method". */ 368 369 extern bool gdbpy_auto_load_enabled (const struct extension_language_defn *); 370 371 /* extension_language_ops "methods". */ 372 373 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer 374 (const struct extension_language_defn *, 375 struct value *value, 376 struct ui_file *stream, int recurse, 377 const struct value_print_options *options, 378 const struct language_defn *language); 379 extern enum ext_lang_bt_status gdbpy_apply_frame_filter 380 (const struct extension_language_defn *, 381 frame_info_ptr frame, frame_filter_flags flags, 382 enum ext_lang_frame_args args_type, 383 struct ui_out *out, int frame_low, int frame_high); 384 extern void gdbpy_preserve_values (const struct extension_language_defn *, 385 struct objfile *objfile, 386 htab_t copied_types); 387 extern enum ext_lang_bp_stop gdbpy_breakpoint_cond_says_stop 388 (const struct extension_language_defn *, struct breakpoint *); 389 extern int gdbpy_breakpoint_has_cond (const struct extension_language_defn *, 390 struct breakpoint *b); 391 392 extern enum ext_lang_rc gdbpy_get_matching_xmethod_workers 393 (const struct extension_language_defn *extlang, 394 struct type *obj_type, const char *method_name, 395 std::vector<xmethod_worker_up> *dm_vec); 396 397 398 PyObject *gdbpy_history (PyObject *self, PyObject *args); 399 PyObject *gdbpy_add_history (PyObject *self, PyObject *args); 400 extern PyObject *gdbpy_history_count (PyObject *self, PyObject *args); 401 PyObject *gdbpy_convenience_variable (PyObject *self, PyObject *args); 402 PyObject *gdbpy_set_convenience_variable (PyObject *self, PyObject *args); 403 PyObject *gdbpy_breakpoints (PyObject *, PyObject *); 404 PyObject *gdbpy_frame_stop_reason_string (PyObject *, PyObject *); 405 PyObject *gdbpy_lookup_symbol (PyObject *self, PyObject *args, PyObject *kw); 406 PyObject *gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, 407 PyObject *kw); 408 PyObject *gdbpy_lookup_static_symbol (PyObject *self, PyObject *args, 409 PyObject *kw); 410 PyObject *gdbpy_lookup_static_symbols (PyObject *self, PyObject *args, 411 PyObject *kw); 412 PyObject *gdbpy_start_recording (PyObject *self, PyObject *args); 413 PyObject *gdbpy_current_recording (PyObject *self, PyObject *args); 414 PyObject *gdbpy_stop_recording (PyObject *self, PyObject *args); 415 PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args); 416 PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args); 417 PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw); 418 int gdbpy_is_field (PyObject *obj); 419 PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length, 420 const char *encoding, 421 struct type *type); 422 PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2); 423 PyObject *gdbpy_create_ptid_object (ptid_t ptid); 424 PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args); 425 PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args); 426 PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args); 427 PyObject *gdbpy_parameter_value (const setting &var); 428 gdb::unique_xmalloc_ptr<char> gdbpy_parse_command_name 429 (const char *name, struct cmd_list_element ***base_list, 430 struct cmd_list_element **start_list); 431 PyObject *gdbpy_register_tui_window (PyObject *self, PyObject *args, 432 PyObject *kw); 433 434 PyObject *symtab_and_line_to_sal_object (struct symtab_and_line sal); 435 PyObject *symtab_to_symtab_object (struct symtab *symtab); 436 PyObject *symbol_to_symbol_object (struct symbol *sym); 437 PyObject *block_to_block_object (const struct block *block, 438 struct objfile *objfile); 439 PyObject *value_to_value_object (struct value *v); 440 PyObject *value_to_value_object_no_release (struct value *v); 441 PyObject *type_to_type_object (struct type *); 442 PyObject *frame_info_to_frame_object (frame_info_ptr frame); 443 PyObject *symtab_to_linetable_object (PyObject *symtab); 444 gdbpy_ref<> pspace_to_pspace_object (struct program_space *); 445 PyObject *pspy_get_printers (PyObject *, void *); 446 PyObject *pspy_get_frame_filters (PyObject *, void *); 447 PyObject *pspy_get_frame_unwinders (PyObject *, void *); 448 PyObject *pspy_get_xmethods (PyObject *, void *); 449 450 gdbpy_ref<> objfile_to_objfile_object (struct objfile *); 451 PyObject *objfpy_get_printers (PyObject *, void *); 452 PyObject *objfpy_get_frame_filters (PyObject *, void *); 453 PyObject *objfpy_get_frame_unwinders (PyObject *, void *); 454 PyObject *objfpy_get_xmethods (PyObject *, void *); 455 PyObject *gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw); 456 457 PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch); 458 PyObject *gdbpy_all_architecture_names (PyObject *self, PyObject *args); 459 460 PyObject *gdbpy_new_register_descriptor_iterator (struct gdbarch *gdbarch, 461 const char *group_name); 462 PyObject *gdbpy_new_reggroup_iterator (struct gdbarch *gdbarch); 463 464 gdbpy_ref<thread_object> create_thread_object (struct thread_info *tp); 465 gdbpy_ref<> thread_to_thread_object (thread_info *thr);; 466 gdbpy_ref<inferior_object> inferior_to_inferior_object (inferior *inf); 467 468 PyObject *gdbpy_buffer_to_membuf (gdb::unique_xmalloc_ptr<gdb_byte> buffer, 469 CORE_ADDR address, ULONGEST length); 470 471 struct process_stratum_target; 472 gdbpy_ref<> target_to_connection_object (process_stratum_target *target); 473 PyObject *gdbpy_connections (PyObject *self, PyObject *args); 474 475 const struct block *block_object_to_block (PyObject *obj); 476 struct symbol *symbol_object_to_symbol (PyObject *obj); 477 struct value *value_object_to_value (PyObject *self); 478 struct value *convert_value_from_python (PyObject *obj); 479 struct type *type_object_to_type (PyObject *obj); 480 struct symtab *symtab_object_to_symtab (PyObject *obj); 481 struct symtab_and_line *sal_object_to_symtab_and_line (PyObject *obj); 482 frame_info_ptr frame_object_to_frame_info (PyObject *frame_obj); 483 struct gdbarch *arch_object_to_gdbarch (PyObject *obj); 484 485 /* Convert Python object OBJ to a program_space pointer. OBJ must be a 486 gdb.Progspace reference. Return nullptr if the gdb.Progspace is not 487 valid (see gdb.Progspace.is_valid), otherwise return the program_space 488 pointer. */ 489 490 extern struct program_space *progspace_object_to_program_space (PyObject *obj); 491 492 void gdbpy_initialize_gdb_readline (void); 493 int gdbpy_initialize_auto_load (void) 494 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 495 int gdbpy_initialize_values (void) 496 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 497 int gdbpy_initialize_frames (void) 498 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 499 int gdbpy_initialize_instruction (void) 500 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 501 int gdbpy_initialize_btrace (void) 502 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 503 int gdbpy_initialize_record (void) 504 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 505 int gdbpy_initialize_symtabs (void) 506 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 507 int gdbpy_initialize_commands (void) 508 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 509 int gdbpy_initialize_symbols (void) 510 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 511 int gdbpy_initialize_symtabs (void) 512 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 513 int gdbpy_initialize_blocks (void) 514 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 515 int gdbpy_initialize_types (void) 516 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 517 int gdbpy_initialize_functions (void) 518 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 519 int gdbpy_initialize_pspace (void) 520 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 521 int gdbpy_initialize_objfile (void) 522 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 523 int gdbpy_initialize_breakpoints (void) 524 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 525 int gdbpy_initialize_breakpoint_locations () 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_arch (void) 544 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 545 int gdbpy_initialize_registers () 546 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 547 int gdbpy_initialize_xmethods (void) 548 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 549 int gdbpy_initialize_unwind (void) 550 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 551 int gdbpy_initialize_tui () 552 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 553 int gdbpy_initialize_membuf () 554 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 555 int gdbpy_initialize_connection () 556 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 557 int gdbpy_initialize_micommands (void) 558 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 559 void gdbpy_finalize_micommands (); 560 int gdbpy_initialize_disasm () 561 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 562 563 PyMODINIT_FUNC gdbpy_events_mod_func (); 564 565 /* A wrapper for PyErr_Fetch that handles reference counting for the 566 caller. */ 567 class gdbpy_err_fetch 568 { 569 public: 570 571 gdbpy_err_fetch () 572 { 573 PyObject *error_type, *error_value, *error_traceback; 574 575 PyErr_Fetch (&error_type, &error_value, &error_traceback); 576 m_error_type.reset (error_type); 577 m_error_value.reset (error_value); 578 m_error_traceback.reset (error_traceback); 579 } 580 581 /* Call PyErr_Restore using the values stashed in this object. 582 After this call, this object is invalid and neither the to_string 583 nor restore methods may be used again. */ 584 585 void restore () 586 { 587 PyErr_Restore (m_error_type.release (), 588 m_error_value.release (), 589 m_error_traceback.release ()); 590 } 591 592 /* Return the string representation of the exception represented by 593 this object. If the result is NULL a python error occurred, the 594 caller must clear it. */ 595 596 gdb::unique_xmalloc_ptr<char> to_string () const; 597 598 /* Return the string representation of the type of the exception 599 represented by this object. If the result is NULL a python error 600 occurred, the caller must clear it. */ 601 602 gdb::unique_xmalloc_ptr<char> type_to_string () const; 603 604 /* Return true if the stored type matches TYPE, false otherwise. */ 605 606 bool type_matches (PyObject *type) const 607 { 608 return PyErr_GivenExceptionMatches (m_error_type.get (), type); 609 } 610 611 /* Return a new reference to the exception value object. */ 612 613 gdbpy_ref<> value () 614 { 615 return m_error_value; 616 } 617 618 private: 619 620 gdbpy_ref<> m_error_type, m_error_value, m_error_traceback; 621 }; 622 623 /* Called before entering the Python interpreter to install the 624 current language and architecture to be used for Python values. 625 Also set the active extension language for GDB so that SIGINT's 626 are directed our way, and if necessary install the right SIGINT 627 handler. */ 628 class gdbpy_enter 629 { 630 public: 631 632 /* Set the ambient Python architecture to GDBARCH and the language 633 to LANGUAGE. If GDBARCH is nullptr, then the architecture will 634 be computed, when needed, using get_current_arch; see the 635 get_gdbarch method. If LANGUAGE is not nullptr, then the current 636 language at time of construction will be saved (to be restored on 637 destruction), and the current language will be set to 638 LANGUAGE. */ 639 explicit gdbpy_enter (struct gdbarch *gdbarch = nullptr, 640 const struct language_defn *language = nullptr); 641 642 ~gdbpy_enter (); 643 644 DISABLE_COPY_AND_ASSIGN (gdbpy_enter); 645 646 /* Return the current gdbarch, as known to the Python layer. This 647 is either python_gdbarch (which comes from the most recent call 648 to the gdbpy_enter constructor), or, if that is nullptr, the 649 result of get_current_arch. */ 650 static struct gdbarch *get_gdbarch (); 651 652 /* Called only during gdb shutdown. This sets python_gdbarch to an 653 acceptable value. */ 654 static void finalize (); 655 656 private: 657 658 /* The current gdbarch, according to Python. This can be 659 nullptr. */ 660 static struct gdbarch *python_gdbarch; 661 662 struct active_ext_lang_state *m_previous_active; 663 PyGILState_STATE m_state; 664 struct gdbarch *m_gdbarch; 665 const struct language_defn *m_language; 666 667 /* An optional is used here because we don't want to call 668 PyErr_Fetch too early. */ 669 gdb::optional<gdbpy_err_fetch> m_error; 670 }; 671 672 /* Like gdbpy_enter, but takes a varobj. This is a subclass just to 673 make constructor delegation a little nicer. */ 674 class gdbpy_enter_varobj : public gdbpy_enter 675 { 676 public: 677 678 /* This is defined in varobj.c, where it can access varobj 679 internals. */ 680 gdbpy_enter_varobj (const struct varobj *var); 681 682 }; 683 684 /* The opposite of gdb_enter: this releases the GIL around a region, 685 allowing other Python threads to run. No Python APIs may be used 686 while this is active. */ 687 class gdbpy_allow_threads 688 { 689 public: 690 691 gdbpy_allow_threads () 692 : m_save (PyEval_SaveThread ()) 693 { 694 gdb_assert (m_save != nullptr); 695 } 696 697 ~gdbpy_allow_threads () 698 { 699 PyEval_RestoreThread (m_save); 700 } 701 702 DISABLE_COPY_AND_ASSIGN (gdbpy_allow_threads); 703 704 private: 705 706 PyThreadState *m_save; 707 }; 708 709 /* Use this after a TRY_EXCEPT to throw the appropriate Python 710 exception. */ 711 #define GDB_PY_HANDLE_EXCEPTION(Exception) \ 712 do { \ 713 if (Exception.reason < 0) \ 714 { \ 715 gdbpy_convert_exception (Exception); \ 716 return NULL; \ 717 } \ 718 } while (0) 719 720 /* Use this after a TRY_EXCEPT to throw the appropriate Python 721 exception. This macro is for use inside setter functions. */ 722 #define GDB_PY_SET_HANDLE_EXCEPTION(Exception) \ 723 do { \ 724 if (Exception.reason < 0) \ 725 { \ 726 gdbpy_convert_exception (Exception); \ 727 return -1; \ 728 } \ 729 } while (0) 730 731 int gdbpy_print_python_errors_p (void); 732 void gdbpy_print_stack (void); 733 void gdbpy_print_stack_or_quit (); 734 void gdbpy_handle_exception () ATTRIBUTE_NORETURN; 735 736 /* A wrapper around calling 'error'. Prefixes the error message with an 737 'Error occurred in Python' string. Use this in C++ code if we spot 738 something wrong with an object returned from Python code. The prefix 739 string gives the user a hint that the mistake is within Python code, 740 rather than some other part of GDB. 741 742 This always calls error, and never returns. */ 743 744 void gdbpy_error (const char *fmt, ...) 745 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (1, 2); 746 747 gdbpy_ref<> python_string_to_unicode (PyObject *obj); 748 gdb::unique_xmalloc_ptr<char> unicode_to_target_string (PyObject *unicode_str); 749 gdb::unique_xmalloc_ptr<char> python_string_to_target_string (PyObject *obj); 750 gdbpy_ref<> python_string_to_target_python_string (PyObject *obj); 751 gdb::unique_xmalloc_ptr<char> python_string_to_host_string (PyObject *obj); 752 gdbpy_ref<> host_string_to_python_string (const char *str); 753 int gdbpy_is_string (PyObject *obj); 754 gdb::unique_xmalloc_ptr<char> gdbpy_obj_to_string (PyObject *obj); 755 756 int gdbpy_is_lazy_string (PyObject *result); 757 void gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr, 758 struct type **str_type, 759 long *length, 760 gdb::unique_xmalloc_ptr<char> *encoding); 761 762 int gdbpy_is_value_object (PyObject *obj); 763 764 /* Note that these are declared here, and not in python.h with the 765 other pretty-printer functions, because they refer to PyObject. */ 766 gdbpy_ref<> apply_varobj_pretty_printer (PyObject *print_obj, 767 struct value **replacement, 768 struct ui_file *stream, 769 const value_print_options *opts); 770 gdbpy_ref<> gdbpy_get_varobj_pretty_printer (struct value *value); 771 gdb::unique_xmalloc_ptr<char> gdbpy_get_display_hint (PyObject *printer); 772 PyObject *gdbpy_default_visualizer (PyObject *self, PyObject *args); 773 774 PyObject *gdbpy_print_options (PyObject *self, PyObject *args); 775 void gdbpy_get_print_options (value_print_options *opts); 776 extern const struct value_print_options *gdbpy_current_print_options; 777 778 void bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj); 779 void bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj); 780 781 extern PyObject *gdbpy_doc_cst; 782 extern PyObject *gdbpy_children_cst; 783 extern PyObject *gdbpy_to_string_cst; 784 extern PyObject *gdbpy_display_hint_cst; 785 extern PyObject *gdbpy_enabled_cst; 786 extern PyObject *gdbpy_value_cst; 787 788 /* Exception types. */ 789 extern PyObject *gdbpy_gdb_error; 790 extern PyObject *gdbpy_gdb_memory_error; 791 extern PyObject *gdbpy_gdberror_exc; 792 793 extern void gdbpy_convert_exception (const struct gdb_exception &) 794 CPYCHECKER_SETS_EXCEPTION; 795 796 int get_addr_from_python (PyObject *obj, CORE_ADDR *addr) 797 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 798 799 gdbpy_ref<> gdb_py_object_from_longest (LONGEST l); 800 gdbpy_ref<> gdb_py_object_from_ulongest (ULONGEST l); 801 int gdb_py_int_as_long (PyObject *, long *); 802 803 PyObject *gdb_py_generic_dict (PyObject *self, void *closure); 804 805 int gdb_pymodule_addobject (PyObject *module, const char *name, 806 PyObject *object) 807 CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; 808 809 struct varobj_iter; 810 struct varobj; 811 std::unique_ptr<varobj_iter> py_varobj_get_iterator 812 (struct varobj *var, 813 PyObject *printer, 814 const value_print_options *opts); 815 816 /* Deleter for Py_buffer unique_ptr specialization. */ 817 818 struct Py_buffer_deleter 819 { 820 void operator() (Py_buffer *b) const 821 { 822 PyBuffer_Release (b); 823 } 824 }; 825 826 /* A unique_ptr specialization for Py_buffer. */ 827 typedef std::unique_ptr<Py_buffer, Py_buffer_deleter> Py_buffer_up; 828 829 /* Parse a register number from PYO_REG_ID and place the register number 830 into *REG_NUM. The register is a register for GDBARCH. 831 832 If a register is parsed successfully then *REG_NUM will have been 833 updated, and true is returned. Otherwise the contents of *REG_NUM are 834 undefined, and false is returned. When false is returned, the 835 Python error is set. 836 837 The PYO_REG_ID object can be a string, the name of the register. This 838 is the slowest approach as GDB has to map the name to a number for each 839 call. Alternatively PYO_REG_ID can be an internal GDB register 840 number. This is quick but should not be encouraged as this means 841 Python scripts are now dependent on GDB's internal register numbering. 842 Final PYO_REG_ID can be a gdb.RegisterDescriptor object, these objects 843 can be looked up by name once, and then cache the register number so 844 should be as quick as using a register number. */ 845 846 extern bool gdbpy_parse_register_id (struct gdbarch *gdbarch, 847 PyObject *pyo_reg_id, int *reg_num); 848 849 /* Return true if OBJ is a gdb.Architecture object, otherwise, return 850 false. */ 851 852 extern bool gdbpy_is_architecture (PyObject *obj); 853 854 /* Return true if OBJ is a gdb.Progspace object, otherwise, return false. */ 855 856 extern bool gdbpy_is_progspace (PyObject *obj); 857 858 /* Take DOC, the documentation string for a GDB command defined in Python, 859 and return an (possibly) modified version of that same string. 860 861 When a command is defined in Python, the documentation string will 862 usually be indented based on the indentation of the surrounding Python 863 code. However, the documentation string is a literal string, all the 864 white-space added for indentation is included within the documentation 865 string. 866 867 This indentation is then included in the help text that GDB displays, 868 which looks odd out of the context of the original Python source code. 869 870 This function analyses DOC and tries to figure out what white-space 871 within DOC was added as part of the indentation, and then removes that 872 white-space from the copy that is returned. 873 874 If the analysis of DOC fails then DOC will be returned unmodified. */ 875 876 extern gdb::unique_xmalloc_ptr<char> gdbpy_fix_doc_string_indentation 877 (gdb::unique_xmalloc_ptr<char> doc); 878 879 /* Implement the 'print_insn' hook for Python. Disassemble an instruction 880 whose address is ADDRESS for architecture GDBARCH. The bytes of the 881 instruction should be read with INFO->read_memory_func as the 882 instruction being disassembled might actually be in a buffer. 883 884 Used INFO->fprintf_func to print the results of the disassembly, and 885 return the length of the instruction in octets. 886 887 If no instruction can be disassembled then return an empty value. */ 888 889 extern gdb::optional<int> gdbpy_print_insn (struct gdbarch *gdbarch, 890 CORE_ADDR address, 891 disassemble_info *info); 892 893 #endif /* PYTHON_PYTHON_INTERNAL_H */ 894