gdb/extension.c

   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
  38 static script_sourcer_func source_gdb_script;
  39 static 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
  44 static 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
  53 const 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
  86 static 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
  98 const struct extension_language_defn *
  99 get_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
 117 static int
 118 has_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
 131 const struct extension_language_defn *
 132 get_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
 149 int
 150 ext_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
 158 int
 159 ext_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
 173 void
 174 throw_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 \f
 181 /* Methods for GDB's own extension/scripting language.  */
 182
 183 /* The extension_language_script_ops.script_sourcer "method".  */
 184
 185 static void
 186 source_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
 194 static void
 195 source_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 \f
 202 /* Accessors for "public" attributes of struct extension_language.  */
 203
 204 /* Return the "name" field of EXTLANG.  */
 205
 206 const char *
 207 ext_lang_name (const struct extension_language_defn *extlang)
 208 {
 209   return extlang->name;
 210 }
 211
 212 /* Return the "capitalized_name" field of EXTLANG.  */
 213
 214 const char *
 215 ext_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
 222 const char *
 223 ext_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
 230 const char *
 231 ext_lang_auto_load_suffix (const struct extension_language_defn *extlang)
 232 {
 233   return extlang->auto_load_suffix;
 234 }
 235 \f
 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
 242 script_sourcer_func *
 243 ext_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
 259 objfile_script_sourcer_func *
 260 ext_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
 276 objfile_script_executor_func *
 277 ext_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
 288 bool
 289 ext_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 \f
 300
 301 /* RAII class used to temporarily return SIG to its default handler.  */
 302
 303 template<int SIG>
 304 struct 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
 314 private:
 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
 321 using 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
 330 void
 331 ext_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
 355 void
 356 eval_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
 382 void
 383 auto_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 \f
 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
 406 ext_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
 421 char *
 422 apply_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
 452 ext_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 \f
 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
 476 int
 477 apply_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
 527 enum ext_lang_bt_status
 528 apply_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
 562 void
 563 preserve_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
 582 const struct extension_language_defn *
 583 get_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
 601 int
 602 breakpoint_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 \f
 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.  */
 640 static 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.  */
 647 static const struct extension_language_defn *active_ext_lang
 648   = &extension_language_gdb;
 649
 650 /* Return the currently active extension language.  */
 651
 652 const struct extension_language_defn *
 653 get_active_ext_lang (void)
 654 {
 655   return active_ext_lang;
 656 }
 657
 658 /* Install a SIGINT handler.  */
 659
 660 static void
 661 install_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
 673 static void
 674 install_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
 687 namespace selftests {
 688 void (*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
 715 struct active_ext_lang_state *
 716 set_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
 751 void
 752 restore_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
 780 void
 781 set_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
 804 int
 805 check_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
 833 void
 834 get_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
 858 std::vector<type *>
 859 xmethod_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
 873 struct type *
 874 xmethod_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
 890 gdb::optional<std::string>
 891 ext_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
 910 gdb::optional<std::string>
 911 ext_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
 930 gdb::optional<int>
 931 ext_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
 953 static void
 954 ext_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
 977 void _initialize_extension ();
 978 void
 979 _initialize_extension ()
 980 {
 981   gdb::observers::before_prompt.attach (ext_lang_before_prompt, "extension");
 982 }