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