Commit | Line | Data |
---|---|---|
6dddc817 DE |
1 | /* Interface between gdb and its extension languages. |
2 | ||
3666a048 | 3 | Copyright (C) 2014-2021 Free Software Foundation, Inc. |
6dddc817 DE |
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> | |
4de283e4 | 25 | #include "target.h" |
6dddc817 DE |
26 | #include "auto-load.h" |
27 | #include "breakpoint.h" | |
28 | #include "event-top.h" | |
d55e5aa6 | 29 | #include "extension.h" |
4de283e4 | 30 | #include "extension-priv.h" |
76727919 | 31 | #include "observable.h" |
4de283e4 | 32 | #include "cli/cli-script.h" |
6dddc817 | 33 | #include "python/python.h" |
4de283e4 | 34 | #include "guile/guile.h" |
38eae084 | 35 | #include <array> |
6dddc817 DE |
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, | |
9f050062 | 48 | NULL, /* objfile_script_executor */ |
6dddc817 DE |
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 | ||
38eae084 | 85 | static const std::array<const extension_language_defn *, 2> extension_languages |
6dddc817 DE |
86 | { |
87 | /* To preserve existing behaviour, python should always appear first. */ | |
88 | &extension_language_python, | |
ed3ef339 | 89 | &extension_language_guile, |
6dddc817 DE |
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 | { | |
6dddc817 DE |
100 | gdb_assert (lang != EXT_LANG_NONE); |
101 | ||
102 | if (lang == EXT_LANG_GDB) | |
103 | return &extension_language_gdb; | |
104 | ||
38eae084 | 105 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
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 | { | |
ed2a2229 CB |
133 | if (has_extension (file, extension_language_gdb.suffix)) |
134 | return &extension_language_gdb; | |
135 | ||
38eae084 | 136 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
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 | ||
9f050062 DE |
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 | ||
db972fce | 285 | /* See extension.h. */ |
6dddc817 | 286 | |
db972fce | 287 | bool |
6dddc817 DE |
288 | ext_lang_auto_load_enabled (const struct extension_language_defn *extlang) |
289 | { | |
290 | if (extlang->script_ops == NULL) | |
db972fce | 291 | return false; |
6dddc817 DE |
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 | /* Functions that iterate over all extension languages. | |
300 | These only iterate over external extension languages, not including | |
301 | GDB's own extension/scripting language, unless otherwise indicated. */ | |
302 | ||
303 | /* Wrapper to call the extension_language_ops.finish_initialization "method" | |
304 | for each compiled-in extension language. */ | |
305 | ||
306 | void | |
307 | finish_ext_lang_initialization (void) | |
308 | { | |
38eae084 | 309 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 310 | { |
38eae084 TT |
311 | if (extlang->ops != nullptr |
312 | && extlang->ops->finish_initialization != NULL) | |
6dddc817 DE |
313 | extlang->ops->finish_initialization (extlang); |
314 | } | |
315 | } | |
316 | ||
317 | /* Invoke the appropriate extension_language_ops.eval_from_control_command | |
318 | method to perform CMD, which is a list of commands in an extension language. | |
319 | ||
320 | This function is what implements, for example: | |
321 | ||
322 | python | |
323 | print 42 | |
324 | end | |
325 | ||
326 | in a GDB script. */ | |
327 | ||
328 | void | |
329 | eval_ext_lang_from_control_command (struct command_line *cmd) | |
330 | { | |
38eae084 | 331 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
332 | { |
333 | if (extlang->cli_control_type == cmd->control_type) | |
334 | { | |
feef67ab DE |
335 | if (extlang->ops != NULL |
336 | && extlang->ops->eval_from_control_command != NULL) | |
6dddc817 DE |
337 | { |
338 | extlang->ops->eval_from_control_command (extlang, cmd); | |
339 | return; | |
340 | } | |
341 | /* The requested extension language is not supported in this GDB. */ | |
342 | throw_ext_lang_unsupported (extlang); | |
343 | } | |
344 | } | |
345 | ||
346 | gdb_assert_not_reached ("unknown extension language in command_line"); | |
347 | } | |
348 | ||
349 | /* Search for and load scripts for OBJFILE written in extension languages. | |
350 | This includes GDB's own scripting language. | |
351 | ||
352 | This function is what implements the loading of OBJFILE-gdb.py and | |
353 | OBJFILE-gdb.gdb. */ | |
354 | ||
355 | void | |
356 | auto_load_ext_lang_scripts_for_objfile (struct objfile *objfile) | |
357 | { | |
38eae084 TT |
358 | const struct extension_language_defn *gdb = &extension_language_gdb; |
359 | if (ext_lang_auto_load_enabled (gdb)) | |
360 | auto_load_objfile_script (objfile, gdb); | |
6dddc817 | 361 | |
38eae084 | 362 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 363 | { |
38eae084 TT |
364 | if (extlang->ops != nullptr |
365 | && ext_lang_auto_load_enabled (extlang)) | |
6dddc817 DE |
366 | auto_load_objfile_script (objfile, extlang); |
367 | } | |
368 | } | |
369 | \f | |
370 | /* Interface to type pretty-printers implemented in an extension language. */ | |
371 | ||
372 | /* Call this at the start when preparing to pretty-print a type. | |
373 | The result is a pointer to an opaque object (to the caller) to be passed | |
374 | to apply_ext_lang_type_printers and free_ext_lang_type_printers. | |
375 | ||
376 | We don't know in advance which extension language will provide a | |
377 | pretty-printer for the type, so all are initialized. */ | |
378 | ||
c819b2c0 | 379 | ext_lang_type_printers::ext_lang_type_printers () |
6dddc817 | 380 | { |
38eae084 | 381 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 382 | { |
38eae084 TT |
383 | if (extlang->ops != nullptr |
384 | && extlang->ops->start_type_printers != NULL) | |
c819b2c0 | 385 | extlang->ops->start_type_printers (extlang, this); |
6dddc817 | 386 | } |
6dddc817 DE |
387 | } |
388 | ||
389 | /* Iteratively try the type pretty-printers specified by PRINTERS | |
390 | according to the standard search order (specified by extension_languages), | |
391 | returning the result of the first one that succeeds. | |
392 | If there was an error, or if no printer succeeds, then NULL is returned. */ | |
393 | ||
394 | char * | |
395 | apply_ext_lang_type_printers (struct ext_lang_type_printers *printers, | |
396 | struct type *type) | |
397 | { | |
38eae084 | 398 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
399 | { |
400 | char *result = NULL; | |
401 | enum ext_lang_rc rc; | |
402 | ||
38eae084 TT |
403 | if (extlang->ops == nullptr |
404 | || extlang->ops->apply_type_printers == NULL) | |
6dddc817 DE |
405 | continue; |
406 | rc = extlang->ops->apply_type_printers (extlang, printers, type, | |
407 | &result); | |
408 | switch (rc) | |
409 | { | |
410 | case EXT_LANG_RC_OK: | |
411 | gdb_assert (result != NULL); | |
412 | return result; | |
413 | case EXT_LANG_RC_ERROR: | |
414 | return NULL; | |
415 | case EXT_LANG_RC_NOP: | |
416 | break; | |
417 | default: | |
418 | gdb_assert_not_reached ("bad return from apply_type_printers"); | |
419 | } | |
420 | } | |
421 | ||
422 | return NULL; | |
423 | } | |
424 | ||
c819b2c0 | 425 | ext_lang_type_printers::~ext_lang_type_printers () |
6dddc817 | 426 | { |
38eae084 | 427 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 428 | { |
38eae084 TT |
429 | if (extlang->ops != nullptr |
430 | && extlang->ops->free_type_printers != NULL) | |
c819b2c0 | 431 | extlang->ops->free_type_printers (extlang, this); |
6dddc817 | 432 | } |
6dddc817 DE |
433 | } |
434 | \f | |
42331a1e TT |
435 | /* Try to pretty-print a value onto stdio stream STREAM according to |
436 | OPTIONS. VAL is the object to print. Returns non-zero if the | |
437 | value was successfully pretty-printed. | |
6dddc817 DE |
438 | |
439 | Extension languages are tried in the order specified by | |
440 | extension_languages. The first one to provide a pretty-printed | |
441 | value "wins". | |
442 | ||
443 | If an error is encountered in a pretty-printer, no further extension | |
444 | languages are tried. | |
445 | Note: This is different than encountering a memory error trying to read a | |
446 | value for pretty-printing. Here we're referring to, e.g., programming | |
447 | errors that trigger an exception in the extension language. */ | |
448 | ||
449 | int | |
42331a1e | 450 | apply_ext_lang_val_pretty_printer (struct value *val, |
6dddc817 | 451 | struct ui_file *stream, int recurse, |
6dddc817 DE |
452 | const struct value_print_options *options, |
453 | const struct language_defn *language) | |
454 | { | |
38eae084 | 455 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
456 | { |
457 | enum ext_lang_rc rc; | |
458 | ||
38eae084 TT |
459 | if (extlang->ops == nullptr |
460 | || extlang->ops->apply_val_pretty_printer == NULL) | |
6dddc817 | 461 | continue; |
42331a1e TT |
462 | rc = extlang->ops->apply_val_pretty_printer (extlang, val, stream, |
463 | recurse, options, language); | |
6dddc817 DE |
464 | switch (rc) |
465 | { | |
466 | case EXT_LANG_RC_OK: | |
467 | return 1; | |
468 | case EXT_LANG_RC_ERROR: | |
469 | return 0; | |
470 | case EXT_LANG_RC_NOP: | |
471 | break; | |
472 | default: | |
473 | gdb_assert_not_reached ("bad return from apply_val_pretty_printer"); | |
474 | } | |
475 | } | |
476 | ||
477 | return 0; | |
478 | } | |
479 | ||
480 | /* GDB access to the "frame filter" feature. | |
481 | FRAME is the source frame to start frame-filter invocation. FLAGS is an | |
482 | integer holding the flags for printing. The following elements of | |
483 | the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS: | |
484 | PRINT_LEVEL is a flag indicating whether to print the frame's | |
485 | relative level in the output. PRINT_FRAME_INFO is a flag that | |
486 | indicates whether this function should print the frame | |
487 | information, PRINT_ARGS is a flag that indicates whether to print | |
488 | frame arguments, and PRINT_LOCALS, likewise, with frame local | |
489 | variables. ARGS_TYPE is an enumerator describing the argument | |
490 | format, OUT is the output stream to print. FRAME_LOW is the | |
491 | beginning of the slice of frames to print, and FRAME_HIGH is the | |
492 | upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error, | |
493 | or EXT_LANG_BT_COMPLETED on success. | |
494 | ||
495 | Extension languages are tried in the order specified by | |
496 | extension_languages. The first one to provide a filter "wins". | |
497 | If there is an error (EXT_LANG_BT_ERROR) it is reported immediately | |
498 | rather than trying filters in other extension languages. */ | |
499 | ||
500 | enum ext_lang_bt_status | |
d4dd3282 TT |
501 | apply_ext_lang_frame_filter (struct frame_info *frame, |
502 | frame_filter_flags flags, | |
6dddc817 DE |
503 | enum ext_lang_frame_args args_type, |
504 | struct ui_out *out, | |
505 | int frame_low, int frame_high) | |
506 | { | |
38eae084 | 507 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
508 | { |
509 | enum ext_lang_bt_status status; | |
510 | ||
38eae084 TT |
511 | if (extlang->ops == nullptr |
512 | || extlang->ops->apply_frame_filter == NULL) | |
6dddc817 DE |
513 | continue; |
514 | status = extlang->ops->apply_frame_filter (extlang, frame, flags, | |
515 | args_type, out, | |
516 | frame_low, frame_high); | |
517 | /* We use the filters from the first extension language that has | |
518 | applicable filters. Also, an error is reported immediately | |
519 | rather than continue trying. */ | |
520 | if (status != EXT_LANG_BT_NO_FILTERS) | |
521 | return status; | |
522 | } | |
523 | ||
524 | return EXT_LANG_BT_NO_FILTERS; | |
525 | } | |
526 | ||
527 | /* Update values held by the extension language when OBJFILE is discarded. | |
528 | New global types must be created for every such value, which must then be | |
529 | updated to use the new types. | |
530 | The function typically just iterates over all appropriate values and | |
531 | calls preserve_one_value for each one. | |
532 | COPIED_TYPES is used to prevent cycles / duplicates and is passed to | |
533 | preserve_one_value. */ | |
534 | ||
535 | void | |
536 | preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types) | |
537 | { | |
38eae084 | 538 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 539 | { |
38eae084 TT |
540 | if (extlang->ops != nullptr |
541 | && extlang->ops->preserve_values != NULL) | |
6dddc817 DE |
542 | extlang->ops->preserve_values (extlang, objfile, copied_types); |
543 | } | |
544 | } | |
545 | ||
546 | /* If there is a stop condition implemented in an extension language for | |
547 | breakpoint B, return a pointer to the extension language's definition. | |
548 | Otherwise return NULL. | |
549 | If SKIP_LANG is not EXT_LANG_NONE, skip checking this language. | |
550 | This is for the case where we're setting a new condition: Only one | |
551 | condition is allowed, so when setting a condition for any particular | |
552 | extension language, we need to check if any other extension language | |
553 | already has a condition set. */ | |
554 | ||
555 | const struct extension_language_defn * | |
556 | get_breakpoint_cond_ext_lang (struct breakpoint *b, | |
557 | enum extension_language skip_lang) | |
558 | { | |
38eae084 | 559 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 560 | { |
38eae084 TT |
561 | if (extlang->ops != nullptr |
562 | && extlang->language != skip_lang | |
6dddc817 DE |
563 | && extlang->ops->breakpoint_has_cond != NULL |
564 | && extlang->ops->breakpoint_has_cond (extlang, b)) | |
565 | return extlang; | |
566 | } | |
567 | ||
568 | return NULL; | |
569 | } | |
570 | ||
571 | /* Return whether a stop condition for breakpoint B says to stop. | |
572 | True is also returned if there is no stop condition for B. */ | |
573 | ||
574 | int | |
575 | breakpoint_ext_lang_cond_says_stop (struct breakpoint *b) | |
576 | { | |
6dddc817 DE |
577 | enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET; |
578 | ||
38eae084 | 579 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
580 | { |
581 | /* There is a rule that a breakpoint can have at most one of any of a | |
582 | CLI or extension language condition. However, Python hacks in "finish | |
583 | breakpoints" on top of the "stop" check, so we have to call this for | |
584 | every language, even if we could first determine whether a "stop" | |
585 | method exists. */ | |
38eae084 TT |
586 | if (extlang->ops != nullptr |
587 | && extlang->ops->breakpoint_cond_says_stop != NULL) | |
6dddc817 DE |
588 | { |
589 | enum ext_lang_bp_stop this_stop | |
590 | = extlang->ops->breakpoint_cond_says_stop (extlang, b); | |
591 | ||
592 | if (this_stop != EXT_LANG_BP_STOP_UNSET) | |
593 | { | |
594 | /* Even though we have to check every extension language, only | |
595 | one of them can return yes/no (because only one of them | |
596 | can have a "stop" condition). */ | |
597 | gdb_assert (stop == EXT_LANG_BP_STOP_UNSET); | |
598 | stop = this_stop; | |
599 | } | |
600 | } | |
601 | } | |
602 | ||
603 | return stop == EXT_LANG_BP_STOP_NO ? 0 : 1; | |
604 | } | |
605 | \f | |
606 | /* ^C/SIGINT support. | |
607 | This requires cooperation with the extension languages so the support | |
608 | is defined here. */ | |
609 | ||
610 | /* This flag tracks quit requests when we haven't called out to an | |
611 | extension language. it also holds quit requests when we transition to | |
612 | an extension language that doesn't have cooperative SIGINT handling. */ | |
613 | static int quit_flag; | |
614 | ||
615 | /* The current extension language we've called out to, or | |
616 | extension_language_gdb if there isn't one. | |
617 | This must be set everytime we call out to an extension language, and reset | |
618 | to the previous value when it returns. Note that the previous value may | |
619 | be a different (or the same) extension language. */ | |
620 | static const struct extension_language_defn *active_ext_lang | |
621 | = &extension_language_gdb; | |
622 | ||
623 | /* Return the currently active extension language. */ | |
624 | ||
625 | const struct extension_language_defn * | |
626 | get_active_ext_lang (void) | |
627 | { | |
628 | return active_ext_lang; | |
629 | } | |
630 | ||
631 | /* Install a SIGINT handler. */ | |
632 | ||
633 | static void | |
634 | install_sigint_handler (const struct signal_handler *handler_state) | |
635 | { | |
636 | gdb_assert (handler_state->handler_saved); | |
637 | ||
638 | signal (SIGINT, handler_state->handler); | |
639 | } | |
640 | ||
641 | /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS. | |
642 | As a simple optimization, if the previous version was GDB's SIGINT handler | |
643 | then mark the previous handler as not having been saved, and thus it won't | |
644 | be restored. */ | |
645 | ||
646 | static void | |
647 | install_gdb_sigint_handler (struct signal_handler *previous) | |
648 | { | |
649 | /* Save here to simplify comparison. */ | |
a40805d4 | 650 | sighandler_t handle_sigint_for_compare = handle_sigint; |
6dddc817 DE |
651 | |
652 | previous->handler = signal (SIGINT, handle_sigint); | |
653 | if (previous->handler != handle_sigint_for_compare) | |
654 | previous->handler_saved = 1; | |
655 | else | |
656 | previous->handler_saved = 0; | |
657 | } | |
658 | ||
659 | /* Set the currently active extension language to NOW_ACTIVE. | |
660 | The result is a pointer to a malloc'd block of memory to pass to | |
661 | restore_active_ext_lang. | |
662 | ||
663 | N.B. This function must be called every time we call out to an extension | |
664 | language, and the result must be passed to restore_active_ext_lang | |
665 | afterwards. | |
666 | ||
667 | If there is a pending SIGINT it is "moved" to the now active extension | |
668 | language, if it supports cooperative SIGINT handling (i.e., it provides | |
669 | {clear,set,check}_quit_flag methods). If the extension language does not | |
670 | support cooperative SIGINT handling, then the SIGINT is left queued and | |
671 | we require the non-cooperative extension language to call check_quit_flag | |
672 | at appropriate times. | |
673 | It is important for the extension language to call check_quit_flag if it | |
674 | installs its own SIGINT handler to prevent the situation where a SIGINT | |
675 | is queued on entry, extension language code runs for a "long" time possibly | |
676 | serving one or more SIGINTs, and then returns. Upon return, if | |
677 | check_quit_flag is not called, the original SIGINT will be thrown. | |
678 | Non-cooperative extension languages are free to install their own SIGINT | |
679 | handler but the original must be restored upon return, either itself | |
680 | or via restore_active_ext_lang. */ | |
681 | ||
682 | struct active_ext_lang_state * | |
683 | set_active_ext_lang (const struct extension_language_defn *now_active) | |
684 | { | |
685 | struct active_ext_lang_state *previous | |
686 | = XCNEW (struct active_ext_lang_state); | |
687 | ||
688 | previous->ext_lang = active_ext_lang; | |
2f99e8fc | 689 | previous->sigint_handler.handler_saved = 0; |
6dddc817 DE |
690 | active_ext_lang = now_active; |
691 | ||
223ffa71 | 692 | if (target_terminal::is_ours ()) |
2f99e8fc YQ |
693 | { |
694 | /* If the newly active extension language uses cooperative SIGINT | |
695 | handling then ensure GDB's SIGINT handler is installed. */ | |
696 | if (now_active->language == EXT_LANG_GDB | |
697 | || now_active->ops->check_quit_flag != NULL) | |
698 | install_gdb_sigint_handler (&previous->sigint_handler); | |
699 | ||
700 | /* If there's a SIGINT recorded in the cooperative extension languages, | |
701 | move it to the new language, or save it in GDB's global flag if the | |
702 | newly active extension language doesn't use cooperative SIGINT | |
703 | handling. */ | |
704 | if (check_quit_flag ()) | |
705 | set_quit_flag (); | |
706 | } | |
6dddc817 DE |
707 | |
708 | return previous; | |
709 | } | |
710 | ||
711 | /* Restore active extension language from PREVIOUS. */ | |
712 | ||
713 | void | |
714 | restore_active_ext_lang (struct active_ext_lang_state *previous) | |
715 | { | |
6dddc817 DE |
716 | active_ext_lang = previous->ext_lang; |
717 | ||
223ffa71 | 718 | if (target_terminal::is_ours ()) |
2f99e8fc YQ |
719 | { |
720 | /* Restore the previous SIGINT handler if one was saved. */ | |
721 | if (previous->sigint_handler.handler_saved) | |
722 | install_sigint_handler (&previous->sigint_handler); | |
723 | ||
724 | /* If there's a SIGINT recorded in the cooperative extension languages, | |
725 | move it to the new language, or save it in GDB's global flag if the | |
726 | newly active extension language doesn't use cooperative SIGINT | |
727 | handling. */ | |
728 | if (check_quit_flag ()) | |
729 | set_quit_flag (); | |
730 | } | |
6dddc817 DE |
731 | xfree (previous); |
732 | } | |
733 | ||
6dddc817 DE |
734 | /* Set the quit flag. |
735 | This only sets the flag in the currently active extension language. | |
736 | If the currently active extension language does not have cooperative | |
737 | SIGINT handling, then GDB's global flag is set, and it is up to the | |
738 | extension language to call check_quit_flag. The extension language | |
739 | is free to install its own SIGINT handler, but we still need to handle | |
740 | the transition. */ | |
741 | ||
742 | void | |
743 | set_quit_flag (void) | |
744 | { | |
745 | if (active_ext_lang->ops != NULL | |
746 | && active_ext_lang->ops->set_quit_flag != NULL) | |
747 | active_ext_lang->ops->set_quit_flag (active_ext_lang); | |
748 | else | |
f0881b37 PA |
749 | { |
750 | quit_flag = 1; | |
751 | ||
752 | /* Now wake up the event loop, or any interruptible_select. Do | |
753 | this after setting the flag, because signals on Windows | |
754 | actually run on a separate thread, and thus otherwise the | |
755 | main code could be woken up and find quit_flag still | |
756 | clear. */ | |
757 | quit_serial_event_set (); | |
758 | } | |
6dddc817 DE |
759 | } |
760 | ||
761 | /* Return true if the quit flag has been set, false otherwise. | |
762 | Note: The flag is cleared as a side-effect. | |
763 | The flag is checked in all extension languages that support cooperative | |
764 | SIGINT handling, not just the current one. This simplifies transitions. */ | |
765 | ||
766 | int | |
767 | check_quit_flag (void) | |
768 | { | |
38eae084 | 769 | int result = 0; |
6dddc817 | 770 | |
38eae084 | 771 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 | 772 | { |
38eae084 TT |
773 | if (extlang->ops != nullptr |
774 | && extlang->ops->check_quit_flag != NULL) | |
6dddc817 DE |
775 | if (extlang->ops->check_quit_flag (extlang) != 0) |
776 | result = 1; | |
777 | } | |
778 | ||
779 | /* This is written in a particular way to avoid races. */ | |
780 | if (quit_flag) | |
781 | { | |
f0881b37 PA |
782 | /* No longer need to wake up the event loop or any |
783 | interruptible_select. The caller handles the quit | |
784 | request. */ | |
785 | quit_serial_event_clear (); | |
6dddc817 DE |
786 | quit_flag = 0; |
787 | result = 1; | |
788 | } | |
789 | ||
790 | return result; | |
791 | } | |
e81e7f5e | 792 | |
ba18742c | 793 | /* See extension.h. */ |
e81e7f5e | 794 | |
ba18742c SM |
795 | void |
796 | get_matching_xmethod_workers (struct type *type, const char *method_name, | |
797 | std::vector<xmethod_worker_up> *workers) | |
e81e7f5e | 798 | { |
38eae084 | 799 | for (const struct extension_language_defn *extlang : extension_languages) |
e81e7f5e | 800 | { |
e81e7f5e SC |
801 | enum ext_lang_rc rc; |
802 | ||
803 | /* If an extension language does not support xmethods, ignore | |
804 | it. */ | |
38eae084 TT |
805 | if (extlang->ops == nullptr |
806 | || extlang->ops->get_matching_xmethod_workers == NULL) | |
e81e7f5e SC |
807 | continue; |
808 | ||
809 | rc = extlang->ops->get_matching_xmethod_workers (extlang, | |
810 | type, method_name, | |
ba18742c | 811 | workers); |
e81e7f5e | 812 | if (rc == EXT_LANG_RC_ERROR) |
ba18742c SM |
813 | error (_("Error while looking for matching xmethod workers " |
814 | "defined in %s."), extlang->capitalized_name); | |
e81e7f5e | 815 | } |
e81e7f5e SC |
816 | } |
817 | ||
ba18742c | 818 | /* See extension.h. */ |
e81e7f5e | 819 | |
6b1747cd PA |
820 | std::vector<type *> |
821 | xmethod_worker::get_arg_types () | |
e81e7f5e | 822 | { |
6b1747cd | 823 | std::vector<type *> type_array; |
e81e7f5e | 824 | |
6b1747cd | 825 | ext_lang_rc rc = do_get_arg_types (&type_array); |
e81e7f5e | 826 | if (rc == EXT_LANG_RC_ERROR) |
ba18742c SM |
827 | error (_("Error while looking for arg types of a xmethod worker " |
828 | "defined in %s."), m_extlang->capitalized_name); | |
e81e7f5e SC |
829 | |
830 | return type_array; | |
831 | } | |
832 | ||
ba18742c | 833 | /* See extension.h. */ |
2ce1cdbf DE |
834 | |
835 | struct type * | |
6b1747cd | 836 | xmethod_worker::get_result_type (value *object, gdb::array_view<value *> args) |
2ce1cdbf | 837 | { |
ba18742c | 838 | type *result_type; |
2ce1cdbf | 839 | |
6b1747cd | 840 | ext_lang_rc rc = do_get_result_type (object, args, &result_type); |
2ce1cdbf DE |
841 | if (rc == EXT_LANG_RC_ERROR) |
842 | { | |
843 | error (_("Error while fetching result type of an xmethod worker " | |
ba18742c | 844 | "defined in %s."), m_extlang->capitalized_name); |
2ce1cdbf DE |
845 | } |
846 | ||
847 | return result_type; | |
848 | } | |
849 | ||
f6474de9 TT |
850 | /* See extension.h. */ |
851 | ||
852 | gdb::optional<std::string> | |
853 | ext_lang_colorize (const std::string &filename, const std::string &contents) | |
854 | { | |
f6474de9 TT |
855 | gdb::optional<std::string> result; |
856 | ||
38eae084 | 857 | for (const struct extension_language_defn *extlang : extension_languages) |
f6474de9 | 858 | { |
38eae084 TT |
859 | if (extlang->ops == nullptr |
860 | || extlang->ops->colorize == nullptr) | |
f6474de9 TT |
861 | continue; |
862 | result = extlang->ops->colorize (filename, contents); | |
863 | if (result.has_value ()) | |
864 | return result; | |
865 | } | |
866 | ||
867 | return result; | |
868 | } | |
869 | ||
6dddc817 DE |
870 | /* Called via an observer before gdb prints its prompt. |
871 | Iterate over the extension languages giving them a chance to | |
872 | change the prompt. The first one to change the prompt wins, | |
873 | and no further languages are tried. */ | |
874 | ||
875 | static void | |
876 | ext_lang_before_prompt (const char *current_gdb_prompt) | |
877 | { | |
38eae084 | 878 | for (const struct extension_language_defn *extlang : extension_languages) |
6dddc817 DE |
879 | { |
880 | enum ext_lang_rc rc; | |
881 | ||
38eae084 TT |
882 | if (extlang->ops == nullptr |
883 | || extlang->ops->before_prompt == NULL) | |
6dddc817 DE |
884 | continue; |
885 | rc = extlang->ops->before_prompt (extlang, current_gdb_prompt); | |
886 | switch (rc) | |
887 | { | |
888 | case EXT_LANG_RC_OK: | |
889 | case EXT_LANG_RC_ERROR: | |
890 | return; | |
891 | case EXT_LANG_RC_NOP: | |
892 | break; | |
893 | default: | |
894 | gdb_assert_not_reached ("bad return from before_prompt"); | |
895 | } | |
896 | } | |
897 | } | |
898 | ||
6c265988 | 899 | void _initialize_extension (); |
6dddc817 | 900 | void |
6c265988 | 901 | _initialize_extension () |
6dddc817 | 902 | { |
76727919 | 903 | gdb::observers::before_prompt.attach (ext_lang_before_prompt); |
6dddc817 | 904 | } |