gdb/extension.c

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