1/* Interface between gdb and its extension languages. 2 3 Copyright (C) 2014-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/* Note: With few exceptions, external functions and variables in this file 21 have "ext_lang" in the name, and no other symbol in gdb does. */ 22 23#include "defs.h" 24#include <signal.h> 25#include "target.h" 26#include "auto-load.h" 27#include "breakpoint.h" 28#include "event-top.h" 29#include "extension.h" 30#include "extension-priv.h" 31#include "observable.h" 32#include "cli/cli-script.h" 33#include "python/python.h" 34#include "guile/guile.h" 35#include <array> 36#include "inferior.h" 37 38static script_sourcer_func source_gdb_script; 39static objfile_script_sourcer_func source_gdb_objfile_script; 40 41/* GDB's own scripting language. 42 This exists, in part, to support auto-loading ${prog}-gdb.gdb scripts. */ 43 44static const struct extension_language_script_ops 45 extension_language_gdb_script_ops = 46{ 47 source_gdb_script, 48 source_gdb_objfile_script, 49 NULL, /* objfile_script_executor */ 50 auto_load_gdb_scripts_enabled 51}; 52 53const struct extension_language_defn extension_language_gdb = 54{ 55 EXT_LANG_GDB, 56 "gdb", 57 "GDB", 58 59 /* We fall back to interpreting a script as a GDB script if it doesn't 60 match the other scripting languages, but for consistency's sake 61 give it a formal suffix. */ 62 ".gdb", 63 "-gdb.gdb", 64 65 /* cli_control_type: This is never used: GDB's own scripting language 66 has a variety of control types (if, while, etc.). */ 67 commands_control, 68 69 &extension_language_gdb_script_ops, 70 71 /* The rest of the extension language interface isn't supported by GDB's own 72 extension/scripting language. */ 73 NULL 74}; 75 76/* NULL-terminated table of all external (non-native) extension languages. 77 78 The order of appearance in the table is important. 79 When multiple extension languages provide the same feature, for example 80 a pretty-printer for a particular type, which one gets used? 81 The algorithm employed here is "the first one wins". For example, in 82 the case of pretty-printers this means the first one to provide a 83 pretty-printed value is the one that is used. This algorithm is employed 84 throughout. */ 85 86static const std::array<const extension_language_defn *, 2> extension_languages 87{ 88 /* To preserve existing behaviour, python should always appear first. */ 89 &extension_language_python, 90 &extension_language_guile, 91}; 92 93/* Return a pointer to the struct extension_language_defn object of 94 extension language LANG. 95 This always returns a non-NULL pointer, even if support for the language 96 is not compiled into this copy of GDB. */ 97 98const struct extension_language_defn * 99get_ext_lang_defn (enum extension_language lang) 100{ 101 gdb_assert (lang != EXT_LANG_NONE); 102 103 if (lang == EXT_LANG_GDB) 104 return &extension_language_gdb; 105 106 for (const struct extension_language_defn *extlang : extension_languages) 107 { 108 if (extlang->language == lang) 109 return extlang; 110 } 111 112 gdb_assert_not_reached ("unable to find extension_language_defn"); 113} 114 115/* Return TRUE if FILE has extension EXTENSION. */ 116 117static int 118has_extension (const char *file, const char *extension) 119{ 120 int file_len = strlen (file); 121 int extension_len = strlen (extension); 122 123 return (file_len > extension_len 124 && strcmp (&file[file_len - extension_len], extension) == 0); 125} 126 127/* Return the extension language of FILE, or NULL if 128 the extension language of FILE is not recognized. 129 This is done by looking at the file's suffix. */ 130 131const struct extension_language_defn * 132get_ext_lang_of_file (const char *file) 133{ 134 if (has_extension (file, extension_language_gdb.suffix)) 135 return &extension_language_gdb; 136 137 for (const struct extension_language_defn *extlang : extension_languages) 138 { 139 if (has_extension (file, extlang->suffix)) 140 return extlang; 141 } 142 143 return NULL; 144} 145 146/* Return non-zero if support for the specified extension language 147 is compiled in. */ 148 149int 150ext_lang_present_p (const struct extension_language_defn *extlang) 151{ 152 return extlang->script_ops != NULL; 153} 154 155/* Return non-zero if the specified extension language has successfully 156 initialized. */ 157 158int 159ext_lang_initialized_p (const struct extension_language_defn *extlang) 160{ 161 if (extlang->ops != NULL) 162 { 163 /* This method is required. */ 164 gdb_assert (extlang->ops->initialized != NULL); 165 return extlang->ops->initialized (extlang); 166 } 167 168 return 0; 169} 170 171/* Throw an error indicating EXTLANG is not supported in this copy of GDB. */ 172 173void 174throw_ext_lang_unsupported (const struct extension_language_defn *extlang) 175{ 176 error (_("Scripting in the \"%s\" language is not supported" 177 " in this copy of GDB."), 178 ext_lang_capitalized_name (extlang)); 179} 180 181/* Methods for GDB's own extension/scripting language. */ 182 183/* The extension_language_script_ops.script_sourcer "method". */ 184 185static void 186source_gdb_script (const struct extension_language_defn *extlang, 187 FILE *stream, const char *file) 188{ 189 script_from_file (stream, file); 190} 191 192/* The extension_language_script_ops.objfile_script_sourcer "method". */ 193 194static void 195source_gdb_objfile_script (const struct extension_language_defn *extlang, 196 struct objfile *objfile, 197 FILE *stream, const char *file) 198{ 199 script_from_file (stream, file); 200} 201 202/* Accessors for "public" attributes of struct extension_language. */ 203 204/* Return the "name" field of EXTLANG. */ 205 206const char * 207ext_lang_name (const struct extension_language_defn *extlang) 208{ 209 return extlang->name; 210} 211 212/* Return the "capitalized_name" field of EXTLANG. */ 213 214const char * 215ext_lang_capitalized_name (const struct extension_language_defn *extlang) 216{ 217 return extlang->capitalized_name; 218} 219 220/* Return the "suffix" field of EXTLANG. */ 221 222const char * 223ext_lang_suffix (const struct extension_language_defn *extlang) 224{ 225 return extlang->suffix; 226} 227 228/* Return the "auto_load_suffix" field of EXTLANG. */ 229 230const char * 231ext_lang_auto_load_suffix (const struct extension_language_defn *extlang) 232{ 233 return extlang->auto_load_suffix; 234} 235 236/* extension_language_script_ops wrappers. */ 237 238/* Return the script "sourcer" function for EXTLANG. 239 This is the function that loads and processes a script. 240 If support for this language isn't compiled in, NULL is returned. */ 241 242script_sourcer_func * 243ext_lang_script_sourcer (const struct extension_language_defn *extlang) 244{ 245 if (extlang->script_ops == NULL) 246 return NULL; 247 248 /* The extension language is required to implement this function. */ 249 gdb_assert (extlang->script_ops->script_sourcer != NULL); 250 251 return extlang->script_ops->script_sourcer; 252} 253 254/* Return the objfile script "sourcer" function for EXTLANG. 255 This is the function that loads and processes a script for a particular 256 objfile. 257 If support for this language isn't compiled in, NULL is returned. */ 258 259objfile_script_sourcer_func * 260ext_lang_objfile_script_sourcer (const struct extension_language_defn *extlang) 261{ 262 if (extlang->script_ops == NULL) 263 return NULL; 264 265 /* The extension language is required to implement this function. */ 266 gdb_assert (extlang->script_ops->objfile_script_sourcer != NULL); 267 268 return extlang->script_ops->objfile_script_sourcer; 269} 270 271/* Return the objfile script "executor" function for EXTLANG. 272 This is the function that executes a script for a particular objfile. 273 If support for this language isn't compiled in, NULL is returned. 274 The extension language is not required to implement this function. */ 275 276objfile_script_executor_func * 277ext_lang_objfile_script_executor 278 (const struct extension_language_defn *extlang) 279{ 280 if (extlang->script_ops == NULL) 281 return NULL; 282 283 return extlang->script_ops->objfile_script_executor; 284} 285 286/* See extension.h. */ 287 288bool 289ext_lang_auto_load_enabled (const struct extension_language_defn *extlang) 290{ 291 if (extlang->script_ops == NULL) 292 return false; 293 294 /* The extension language is required to implement this function. */ 295 gdb_assert (extlang->script_ops->auto_load_enabled != NULL); 296 297 return extlang->script_ops->auto_load_enabled (extlang); 298} 299 300 301/* RAII class used to temporarily return SIG to its default handler. */ 302 303template<int SIG> 304struct scoped_default_signal 305{ 306 scoped_default_signal () 307 { m_old_sig_handler = signal (SIG, SIG_DFL); } 308 309 ~scoped_default_signal () 310 { signal (SIG, m_old_sig_handler); } 311 312 DISABLE_COPY_AND_ASSIGN (scoped_default_signal); 313 314private: 315 /* The previous signal handler that needs to be restored. */ 316 sighandler_t m_old_sig_handler; 317}; 318 319/* Class to temporarily return SIGINT to its default handler. */ 320 321using scoped_default_sigint = scoped_default_signal<SIGINT>; 322 323/* Functions that iterate over all extension languages. 324 These only iterate over external extension languages, not including 325 GDB's own extension/scripting language, unless otherwise indicated. */ 326 327/* Wrapper to call the extension_language_ops.initialize "method" for each 328 compiled-in extension language. */ 329 330void 331ext_lang_initialization (void) 332{ 333 for (const struct extension_language_defn *extlang : extension_languages) 334 { 335 if (extlang->ops != nullptr 336 && extlang->ops->initialize != NULL) 337 { 338 scoped_default_sigint set_sigint_to_default_handler; 339 extlang->ops->initialize (extlang); 340 } 341 } 342} 343 344/* Invoke the appropriate extension_language_ops.eval_from_control_command 345 method to perform CMD, which is a list of commands in an extension language. 346 347 This function is what implements, for example: 348 349 python 350 print 42 351 end 352 353 in a GDB script. */ 354 355void 356eval_ext_lang_from_control_command (struct command_line *cmd) 357{ 358 for (const struct extension_language_defn *extlang : extension_languages) 359 { 360 if (extlang->cli_control_type == cmd->control_type) 361 { 362 if (extlang->ops != NULL 363 && extlang->ops->eval_from_control_command != NULL) 364 { 365 extlang->ops->eval_from_control_command (extlang, cmd); 366 return; 367 } 368 /* The requested extension language is not supported in this GDB. */ 369 throw_ext_lang_unsupported (extlang); 370 } 371 } 372 373 gdb_assert_not_reached ("unknown extension language in command_line"); 374} 375 376/* Search for and load scripts for OBJFILE written in extension languages. 377 This includes GDB's own scripting language. 378 379 This function is what implements the loading of OBJFILE-gdb.py and 380 OBJFILE-gdb.gdb. */ 381 382void 383auto_load_ext_lang_scripts_for_objfile (struct objfile *objfile) 384{ 385 const struct extension_language_defn *gdb = &extension_language_gdb; 386 if (ext_lang_auto_load_enabled (gdb)) 387 auto_load_objfile_script (objfile, gdb); 388 389 for (const struct extension_language_defn *extlang : extension_languages) 390 { 391 if (extlang->ops != nullptr 392 && ext_lang_auto_load_enabled (extlang)) 393 auto_load_objfile_script (objfile, extlang); 394 } 395} 396 397/* Interface to type pretty-printers implemented in an extension language. */ 398 399/* Call this at the start when preparing to pretty-print a type. 400 The result is a pointer to an opaque object (to the caller) to be passed 401 to apply_ext_lang_type_printers and free_ext_lang_type_printers. 402 403 We don't know in advance which extension language will provide a 404 pretty-printer for the type, so all are initialized. */ 405 406ext_lang_type_printers::ext_lang_type_printers () 407{ 408 for (const struct extension_language_defn *extlang : extension_languages) 409 { 410 if (extlang->ops != nullptr 411 && extlang->ops->start_type_printers != NULL) 412 extlang->ops->start_type_printers (extlang, this); 413 } 414} 415 416/* Iteratively try the type pretty-printers specified by PRINTERS 417 according to the standard search order (specified by extension_languages), 418 returning the result of the first one that succeeds. 419 If there was an error, or if no printer succeeds, then NULL is returned. */ 420 421char * 422apply_ext_lang_type_printers (struct ext_lang_type_printers *printers, 423 struct type *type) 424{ 425 for (const struct extension_language_defn *extlang : extension_languages) 426 { 427 char *result = NULL; 428 enum ext_lang_rc rc; 429 430 if (extlang->ops == nullptr 431 || extlang->ops->apply_type_printers == NULL) 432 continue; 433 rc = extlang->ops->apply_type_printers (extlang, printers, type, 434 &result); 435 switch (rc) 436 { 437 case EXT_LANG_RC_OK: 438 gdb_assert (result != NULL); 439 return result; 440 case EXT_LANG_RC_ERROR: 441 return NULL; 442 case EXT_LANG_RC_NOP: 443 break; 444 default: 445 gdb_assert_not_reached ("bad return from apply_type_printers"); 446 } 447 } 448 449 return NULL; 450} 451 452ext_lang_type_printers::~ext_lang_type_printers () 453{ 454 for (const struct extension_language_defn *extlang : extension_languages) 455 { 456 if (extlang->ops != nullptr 457 && extlang->ops->free_type_printers != NULL) 458 extlang->ops->free_type_printers (extlang, this); 459 } 460} 461 462/* Try to pretty-print a value onto stdio stream STREAM according to 463 OPTIONS. VAL is the object to print. Returns non-zero if the 464 value was successfully pretty-printed. 465 466 Extension languages are tried in the order specified by 467 extension_languages. The first one to provide a pretty-printed 468 value "wins". 469 470 If an error is encountered in a pretty-printer, no further extension 471 languages are tried. 472 Note: This is different than encountering a memory error trying to read a 473 value for pretty-printing. Here we're referring to, e.g., programming 474 errors that trigger an exception in the extension language. */ 475 476int 477apply_ext_lang_val_pretty_printer (struct value *val, 478 struct ui_file *stream, int recurse, 479 const struct value_print_options *options, 480 const struct language_defn *language) 481{ 482 for (const struct extension_language_defn *extlang : extension_languages) 483 { 484 enum ext_lang_rc rc; 485 486 if (extlang->ops == nullptr 487 || extlang->ops->apply_val_pretty_printer == NULL) 488 continue; 489 rc = extlang->ops->apply_val_pretty_printer (extlang, val, stream, 490 recurse, options, language); 491 switch (rc) 492 { 493 case EXT_LANG_RC_OK: 494 return 1; 495 case EXT_LANG_RC_ERROR: 496 return 0; 497 case EXT_LANG_RC_NOP: 498 break; 499 default: 500 gdb_assert_not_reached ("bad return from apply_val_pretty_printer"); 501 } 502 } 503 504 return 0; 505} 506 507/* GDB access to the "frame filter" feature. 508 FRAME is the source frame to start frame-filter invocation. FLAGS is an 509 integer holding the flags for printing. The following elements of 510 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS: 511 PRINT_LEVEL is a flag indicating whether to print the frame's 512 relative level in the output. PRINT_FRAME_INFO is a flag that 513 indicates whether this function should print the frame 514 information, PRINT_ARGS is a flag that indicates whether to print 515 frame arguments, and PRINT_LOCALS, likewise, with frame local 516 variables. ARGS_TYPE is an enumerator describing the argument 517 format, OUT is the output stream to print. FRAME_LOW is the 518 beginning of the slice of frames to print, and FRAME_HIGH is the 519 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error, 520 or EXT_LANG_BT_COMPLETED on success. 521 522 Extension languages are tried in the order specified by 523 extension_languages. The first one to provide a filter "wins". 524 If there is an error (EXT_LANG_BT_ERROR) it is reported immediately 525 rather than trying filters in other extension languages. */ 526 527enum ext_lang_bt_status 528apply_ext_lang_frame_filter (frame_info_ptr frame, 529 frame_filter_flags flags, 530 enum ext_lang_frame_args args_type, 531 struct ui_out *out, 532 int frame_low, int frame_high) 533{ 534 for (const struct extension_language_defn *extlang : extension_languages) 535 { 536 enum ext_lang_bt_status status; 537 538 if (extlang->ops == nullptr 539 || extlang->ops->apply_frame_filter == NULL) 540 continue; 541 status = extlang->ops->apply_frame_filter (extlang, frame, flags, 542 args_type, out, 543 frame_low, frame_high); 544 /* We use the filters from the first extension language that has 545 applicable filters. Also, an error is reported immediately 546 rather than continue trying. */ 547 if (status != EXT_LANG_BT_NO_FILTERS) 548 return status; 549 } 550 551 return EXT_LANG_BT_NO_FILTERS; 552} 553 554/* Update values held by the extension language when OBJFILE is discarded. 555 New global types must be created for every such value, which must then be 556 updated to use the new types. 557 The function typically just iterates over all appropriate values and 558 calls preserve_one_value for each one. 559 COPIED_TYPES is used to prevent cycles / duplicates and is passed to 560 preserve_one_value. */ 561 562void 563preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types) 564{ 565 for (const struct extension_language_defn *extlang : extension_languages) 566 { 567 if (extlang->ops != nullptr 568 && extlang->ops->preserve_values != NULL) 569 extlang->ops->preserve_values (extlang, objfile, copied_types); 570 } 571} 572 573/* If there is a stop condition implemented in an extension language for 574 breakpoint B, return a pointer to the extension language's definition. 575 Otherwise return NULL. 576 If SKIP_LANG is not EXT_LANG_NONE, skip checking this language. 577 This is for the case where we're setting a new condition: Only one 578 condition is allowed, so when setting a condition for any particular 579 extension language, we need to check if any other extension language 580 already has a condition set. */ 581 582const struct extension_language_defn * 583get_breakpoint_cond_ext_lang (struct breakpoint *b, 584 enum extension_language skip_lang) 585{ 586 for (const struct extension_language_defn *extlang : extension_languages) 587 { 588 if (extlang->ops != nullptr 589 && extlang->language != skip_lang 590 && extlang->ops->breakpoint_has_cond != NULL 591 && extlang->ops->breakpoint_has_cond (extlang, b)) 592 return extlang; 593 } 594 595 return NULL; 596} 597 598/* Return whether a stop condition for breakpoint B says to stop. 599 True is also returned if there is no stop condition for B. */ 600 601int 602breakpoint_ext_lang_cond_says_stop (struct breakpoint *b) 603{ 604 enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET; 605 606 for (const struct extension_language_defn *extlang : extension_languages) 607 { 608 /* There is a rule that a breakpoint can have at most one of any of a 609 CLI or extension language condition. However, Python hacks in "finish 610 breakpoints" on top of the "stop" check, so we have to call this for 611 every language, even if we could first determine whether a "stop" 612 method exists. */ 613 if (extlang->ops != nullptr 614 && extlang->ops->breakpoint_cond_says_stop != NULL) 615 { 616 enum ext_lang_bp_stop this_stop 617 = extlang->ops->breakpoint_cond_says_stop (extlang, b); 618 619 if (this_stop != EXT_LANG_BP_STOP_UNSET) 620 { 621 /* Even though we have to check every extension language, only 622 one of them can return yes/no (because only one of them 623 can have a "stop" condition). */ 624 gdb_assert (stop == EXT_LANG_BP_STOP_UNSET); 625 stop = this_stop; 626 } 627 } 628 } 629 630 return stop == EXT_LANG_BP_STOP_NO ? 0 : 1; 631} 632 633/* ^C/SIGINT support. 634 This requires cooperation with the extension languages so the support 635 is defined here. */ 636 637/* This flag tracks quit requests when we haven't called out to an 638 extension language. it also holds quit requests when we transition to 639 an extension language that doesn't have cooperative SIGINT handling. */ 640static int quit_flag; 641 642/* The current extension language we've called out to, or 643 extension_language_gdb if there isn't one. 644 This must be set everytime we call out to an extension language, and reset 645 to the previous value when it returns. Note that the previous value may 646 be a different (or the same) extension language. */ 647static const struct extension_language_defn *active_ext_lang 648 = &extension_language_gdb; 649 650/* Return the currently active extension language. */ 651 652const struct extension_language_defn * 653get_active_ext_lang (void) 654{ 655 return active_ext_lang; 656} 657 658/* Install a SIGINT handler. */ 659 660static void 661install_ext_sigint_handler (const struct signal_handler *handler_state) 662{ 663 gdb_assert (handler_state->handler_saved); 664 665 install_sigint_handler (handler_state->handler); 666} 667 668/* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS. 669 As a simple optimization, if the previous version was GDB's SIGINT handler 670 then mark the previous handler as not having been saved, and thus it won't 671 be restored. */ 672 673static void 674install_gdb_sigint_handler (struct signal_handler *previous) 675{ 676 /* Save here to simplify comparison. */ 677 sighandler_t handle_sigint_for_compare = handle_sigint; 678 679 previous->handler = install_sigint_handler (handle_sigint); 680 if (previous->handler != handle_sigint_for_compare) 681 previous->handler_saved = 1; 682 else 683 previous->handler_saved = 0; 684} 685 686#if GDB_SELF_TEST 687namespace selftests { 688void (*hook_set_active_ext_lang) () = nullptr; 689} 690#endif 691 692/* Set the currently active extension language to NOW_ACTIVE. 693 The result is a pointer to a malloc'd block of memory to pass to 694 restore_active_ext_lang. 695 696 N.B. This function must be called every time we call out to an extension 697 language, and the result must be passed to restore_active_ext_lang 698 afterwards. 699 700 If there is a pending SIGINT it is "moved" to the now active extension 701 language, if it supports cooperative SIGINT handling (i.e., it provides 702 {clear,set,check}_quit_flag methods). If the extension language does not 703 support cooperative SIGINT handling, then the SIGINT is left queued and 704 we require the non-cooperative extension language to call check_quit_flag 705 at appropriate times. 706 It is important for the extension language to call check_quit_flag if it 707 installs its own SIGINT handler to prevent the situation where a SIGINT 708 is queued on entry, extension language code runs for a "long" time possibly 709 serving one or more SIGINTs, and then returns. Upon return, if 710 check_quit_flag is not called, the original SIGINT will be thrown. 711 Non-cooperative extension languages are free to install their own SIGINT 712 handler but the original must be restored upon return, either itself 713 or via restore_active_ext_lang. */ 714 715struct active_ext_lang_state * 716set_active_ext_lang (const struct extension_language_defn *now_active) 717{ 718#if GDB_SELF_TEST 719 if (selftests::hook_set_active_ext_lang) 720 selftests::hook_set_active_ext_lang (); 721#endif 722 723 struct active_ext_lang_state *previous 724 = XCNEW (struct active_ext_lang_state); 725 726 previous->ext_lang = active_ext_lang; 727 previous->sigint_handler.handler_saved = 0; 728 active_ext_lang = now_active; 729 730 if (target_terminal::is_ours ()) 731 { 732 /* If the newly active extension language uses cooperative SIGINT 733 handling then ensure GDB's SIGINT handler is installed. */ 734 if (now_active->language == EXT_LANG_GDB 735 || now_active->ops->check_quit_flag != NULL) 736 install_gdb_sigint_handler (&previous->sigint_handler); 737 738 /* If there's a SIGINT recorded in the cooperative extension languages, 739 move it to the new language, or save it in GDB's global flag if the 740 newly active extension language doesn't use cooperative SIGINT 741 handling. */ 742 if (check_quit_flag ()) 743 set_quit_flag (); 744 } 745 746 return previous; 747} 748 749/* Restore active extension language from PREVIOUS. */ 750 751void 752restore_active_ext_lang (struct active_ext_lang_state *previous) 753{ 754 active_ext_lang = previous->ext_lang; 755 756 if (target_terminal::is_ours ()) 757 { 758 /* Restore the previous SIGINT handler if one was saved. */ 759 if (previous->sigint_handler.handler_saved) 760 install_ext_sigint_handler (&previous->sigint_handler); 761 762 /* If there's a SIGINT recorded in the cooperative extension languages, 763 move it to the new language, or save it in GDB's global flag if the 764 newly active extension language doesn't use cooperative SIGINT 765 handling. */ 766 if (check_quit_flag ()) 767 set_quit_flag (); 768 } 769 xfree (previous); 770} 771 772/* Set the quit flag. 773 This only sets the flag in the currently active extension language. 774 If the currently active extension language does not have cooperative 775 SIGINT handling, then GDB's global flag is set, and it is up to the 776 extension language to call check_quit_flag. The extension language 777 is free to install its own SIGINT handler, but we still need to handle 778 the transition. */ 779 780void 781set_quit_flag (void) 782{ 783 if (active_ext_lang->ops != NULL 784 && active_ext_lang->ops->set_quit_flag != NULL) 785 active_ext_lang->ops->set_quit_flag (active_ext_lang); 786 else 787 { 788 quit_flag = 1; 789 790 /* Now wake up the event loop, or any interruptible_select. Do 791 this after setting the flag, because signals on Windows 792 actually run on a separate thread, and thus otherwise the 793 main code could be woken up and find quit_flag still 794 clear. */ 795 quit_serial_event_set (); 796 } 797} 798 799/* Return true if the quit flag has been set, false otherwise. 800 Note: The flag is cleared as a side-effect. 801 The flag is checked in all extension languages that support cooperative 802 SIGINT handling, not just the current one. This simplifies transitions. */ 803 804int 805check_quit_flag (void) 806{ 807 int result = 0; 808 809 for (const struct extension_language_defn *extlang : extension_languages) 810 { 811 if (extlang->ops != nullptr 812 && extlang->ops->check_quit_flag != NULL) 813 if (extlang->ops->check_quit_flag (extlang) != 0) 814 result = 1; 815 } 816 817 /* This is written in a particular way to avoid races. */ 818 if (quit_flag) 819 { 820 /* No longer need to wake up the event loop or any 821 interruptible_select. The caller handles the quit 822 request. */ 823 quit_serial_event_clear (); 824 quit_flag = 0; 825 result = 1; 826 } 827 828 return result; 829} 830 831/* See extension.h. */ 832 833void 834get_matching_xmethod_workers (struct type *type, const char *method_name, 835 std::vector<xmethod_worker_up> *workers) 836{ 837 for (const struct extension_language_defn *extlang : extension_languages) 838 { 839 enum ext_lang_rc rc; 840 841 /* If an extension language does not support xmethods, ignore 842 it. */ 843 if (extlang->ops == nullptr 844 || extlang->ops->get_matching_xmethod_workers == NULL) 845 continue; 846 847 rc = extlang->ops->get_matching_xmethod_workers (extlang, 848 type, method_name, 849 workers); 850 if (rc == EXT_LANG_RC_ERROR) 851 error (_("Error while looking for matching xmethod workers " 852 "defined in %s."), extlang->capitalized_name); 853 } 854} 855 856/* See extension.h. */ 857 858std::vector<type *> 859xmethod_worker::get_arg_types () 860{ 861 std::vector<type *> type_array; 862 863 ext_lang_rc rc = do_get_arg_types (&type_array); 864 if (rc == EXT_LANG_RC_ERROR) 865 error (_("Error while looking for arg types of a xmethod worker " 866 "defined in %s."), m_extlang->capitalized_name); 867 868 return type_array; 869} 870 871/* See extension.h. */ 872 873struct type * 874xmethod_worker::get_result_type (value *object, gdb::array_view<value *> args) 875{ 876 type *result_type; 877 878 ext_lang_rc rc = do_get_result_type (object, args, &result_type); 879 if (rc == EXT_LANG_RC_ERROR) 880 { 881 error (_("Error while fetching result type of an xmethod worker " 882 "defined in %s."), m_extlang->capitalized_name); 883 } 884 885 return result_type; 886} 887 888/* See extension.h. */ 889 890gdb::optional<std::string> 891ext_lang_colorize (const std::string &filename, const std::string &contents) 892{ 893 gdb::optional<std::string> result; 894 895 for (const struct extension_language_defn *extlang : extension_languages) 896 { 897 if (extlang->ops == nullptr 898 || extlang->ops->colorize == nullptr) 899 continue; 900 result = extlang->ops->colorize (filename, contents); 901 if (result.has_value ()) 902 return result; 903 } 904 905 return result; 906} 907 908/* See extension.h. */ 909 910gdb::optional<std::string> 911ext_lang_colorize_disasm (const std::string &content, gdbarch *gdbarch) 912{ 913 gdb::optional<std::string> result; 914 915 for (const struct extension_language_defn *extlang : extension_languages) 916 { 917 if (extlang->ops == nullptr 918 || extlang->ops->colorize_disasm == nullptr) 919 continue; 920 result = extlang->ops->colorize_disasm (content, gdbarch); 921 if (result.has_value ()) 922 return result; 923 } 924 925 return result; 926} 927 928/* See extension.h. */ 929 930gdb::optional<int> 931ext_lang_print_insn (struct gdbarch *gdbarch, CORE_ADDR address, 932 struct disassemble_info *info) 933{ 934 for (const struct extension_language_defn *extlang : extension_languages) 935 { 936 if (extlang->ops == nullptr 937 || extlang->ops->print_insn == nullptr) 938 continue; 939 gdb::optional<int> length 940 = extlang->ops->print_insn (gdbarch, address, info); 941 if (length.has_value ()) 942 return length; 943 } 944 945 return {}; 946} 947 948/* Called via an observer before gdb prints its prompt. 949 Iterate over the extension languages giving them a chance to 950 change the prompt. The first one to change the prompt wins, 951 and no further languages are tried. */ 952 953static void 954ext_lang_before_prompt (const char *current_gdb_prompt) 955{ 956 for (const struct extension_language_defn *extlang : extension_languages) 957 { 958 enum ext_lang_rc rc; 959 960 if (extlang->ops == nullptr 961 || extlang->ops->before_prompt == NULL) 962 continue; 963 rc = extlang->ops->before_prompt (extlang, current_gdb_prompt); 964 switch (rc) 965 { 966 case EXT_LANG_RC_OK: 967 case EXT_LANG_RC_ERROR: 968 return; 969 case EXT_LANG_RC_NOP: 970 break; 971 default: 972 gdb_assert_not_reached ("bad return from before_prompt"); 973 } 974 } 975} 976 977void _initialize_extension (); 978void 979_initialize_extension () 980{ 981 gdb::observers::before_prompt.attach (ext_lang_before_prompt, "extension"); 982} 983