gdb/extension.c

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