Commit | Line | Data |
---|---|---|
6dddc817 DE |
1 | /* Interface between gdb and its extension languages. |
2 | ||
61baf725 | 3 | Copyright (C) 2014-2017 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> | |
2f99e8fc | 25 | #include "target.h" |
6dddc817 DE |
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 "observer.h" | |
32 | #include "cli/cli-script.h" | |
33 | #include "python/python.h" | |
ed3ef339 | 34 | #include "guile/guile.h" |
6dddc817 DE |
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, | |
9f050062 | 65 | NULL, /* objfile_script_executor */ |
6dddc817 DE |
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, | |
ed3ef339 | 106 | &extension_language_guile, |
6dddc817 DE |
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 | ALL_EXTENSION_LANGUAGES (i, extlang) | |
158 | { | |
159 | if (has_extension (file, extlang->suffix)) | |
160 | return extlang; | |
161 | } | |
162 | ||
163 | return NULL; | |
164 | } | |
165 | ||
166 | /* Return non-zero if support for the specified extension language | |
167 | is compiled in. */ | |
168 | ||
169 | int | |
170 | ext_lang_present_p (const struct extension_language_defn *extlang) | |
171 | { | |
172 | return extlang->script_ops != NULL; | |
173 | } | |
174 | ||
175 | /* Return non-zero if the specified extension language has successfully | |
176 | initialized. */ | |
177 | ||
178 | int | |
179 | ext_lang_initialized_p (const struct extension_language_defn *extlang) | |
180 | { | |
181 | if (extlang->ops != NULL) | |
182 | { | |
183 | /* This method is required. */ | |
184 | gdb_assert (extlang->ops->initialized != NULL); | |
185 | return extlang->ops->initialized (extlang); | |
186 | } | |
187 | ||
188 | return 0; | |
189 | } | |
190 | ||
191 | /* Throw an error indicating EXTLANG is not supported in this copy of GDB. */ | |
192 | ||
193 | void | |
194 | throw_ext_lang_unsupported (const struct extension_language_defn *extlang) | |
195 | { | |
196 | error (_("Scripting in the \"%s\" language is not supported" | |
197 | " in this copy of GDB."), | |
198 | ext_lang_capitalized_name (extlang)); | |
199 | } | |
200 | \f | |
201 | /* Methods for GDB's own extension/scripting language. */ | |
202 | ||
203 | /* The extension_language_script_ops.script_sourcer "method". */ | |
204 | ||
205 | static void | |
206 | source_gdb_script (const struct extension_language_defn *extlang, | |
207 | FILE *stream, const char *file) | |
208 | { | |
209 | script_from_file (stream, file); | |
210 | } | |
211 | ||
212 | /* The extension_language_script_ops.objfile_script_sourcer "method". */ | |
213 | ||
214 | static void | |
215 | source_gdb_objfile_script (const struct extension_language_defn *extlang, | |
216 | struct objfile *objfile, | |
217 | FILE *stream, const char *file) | |
218 | { | |
219 | script_from_file (stream, file); | |
220 | } | |
221 | \f | |
222 | /* Accessors for "public" attributes of struct extension_language. */ | |
223 | ||
224 | /* Return the "name" field of EXTLANG. */ | |
225 | ||
226 | const char * | |
227 | ext_lang_name (const struct extension_language_defn *extlang) | |
228 | { | |
229 | return extlang->name; | |
230 | } | |
231 | ||
232 | /* Return the "capitalized_name" field of EXTLANG. */ | |
233 | ||
234 | const char * | |
235 | ext_lang_capitalized_name (const struct extension_language_defn *extlang) | |
236 | { | |
237 | return extlang->capitalized_name; | |
238 | } | |
239 | ||
240 | /* Return the "suffix" field of EXTLANG. */ | |
241 | ||
242 | const char * | |
243 | ext_lang_suffix (const struct extension_language_defn *extlang) | |
244 | { | |
245 | return extlang->suffix; | |
246 | } | |
247 | ||
248 | /* Return the "auto_load_suffix" field of EXTLANG. */ | |
249 | ||
250 | const char * | |
251 | ext_lang_auto_load_suffix (const struct extension_language_defn *extlang) | |
252 | { | |
253 | return extlang->auto_load_suffix; | |
254 | } | |
255 | \f | |
256 | /* extension_language_script_ops wrappers. */ | |
257 | ||
258 | /* Return the script "sourcer" function for EXTLANG. | |
259 | This is the function that loads and processes a script. | |
260 | If support for this language isn't compiled in, NULL is returned. */ | |
261 | ||
262 | script_sourcer_func * | |
263 | ext_lang_script_sourcer (const struct extension_language_defn *extlang) | |
264 | { | |
265 | if (extlang->script_ops == NULL) | |
266 | return NULL; | |
267 | ||
268 | /* The extension language is required to implement this function. */ | |
269 | gdb_assert (extlang->script_ops->script_sourcer != NULL); | |
270 | ||
271 | return extlang->script_ops->script_sourcer; | |
272 | } | |
273 | ||
274 | /* Return the objfile script "sourcer" function for EXTLANG. | |
275 | This is the function that loads and processes a script for a particular | |
276 | objfile. | |
277 | If support for this language isn't compiled in, NULL is returned. */ | |
278 | ||
279 | objfile_script_sourcer_func * | |
280 | ext_lang_objfile_script_sourcer (const struct extension_language_defn *extlang) | |
281 | { | |
282 | if (extlang->script_ops == NULL) | |
283 | return NULL; | |
284 | ||
285 | /* The extension language is required to implement this function. */ | |
286 | gdb_assert (extlang->script_ops->objfile_script_sourcer != NULL); | |
287 | ||
288 | return extlang->script_ops->objfile_script_sourcer; | |
289 | } | |
290 | ||
9f050062 DE |
291 | /* Return the objfile script "executor" function for EXTLANG. |
292 | This is the function that executes a script for a particular objfile. | |
293 | If support for this language isn't compiled in, NULL is returned. | |
294 | The extension language is not required to implement this function. */ | |
295 | ||
296 | objfile_script_executor_func * | |
297 | ext_lang_objfile_script_executor | |
298 | (const struct extension_language_defn *extlang) | |
299 | { | |
300 | if (extlang->script_ops == NULL) | |
301 | return NULL; | |
302 | ||
303 | return extlang->script_ops->objfile_script_executor; | |
304 | } | |
305 | ||
6dddc817 DE |
306 | /* Return non-zero if auto-loading of EXTLANG scripts is enabled. |
307 | Zero is returned if support for this language isn't compiled in. */ | |
308 | ||
309 | int | |
310 | ext_lang_auto_load_enabled (const struct extension_language_defn *extlang) | |
311 | { | |
312 | if (extlang->script_ops == NULL) | |
313 | return 0; | |
314 | ||
315 | /* The extension language is required to implement this function. */ | |
316 | gdb_assert (extlang->script_ops->auto_load_enabled != NULL); | |
317 | ||
318 | return extlang->script_ops->auto_load_enabled (extlang); | |
319 | } | |
320 | \f | |
321 | /* Functions that iterate over all extension languages. | |
322 | These only iterate over external extension languages, not including | |
323 | GDB's own extension/scripting language, unless otherwise indicated. */ | |
324 | ||
325 | /* Wrapper to call the extension_language_ops.finish_initialization "method" | |
326 | for each compiled-in extension language. */ | |
327 | ||
328 | void | |
329 | finish_ext_lang_initialization (void) | |
330 | { | |
331 | int i; | |
332 | const struct extension_language_defn *extlang; | |
333 | ||
334 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
335 | { | |
336 | if (extlang->ops->finish_initialization != NULL) | |
337 | extlang->ops->finish_initialization (extlang); | |
338 | } | |
339 | } | |
340 | ||
341 | /* Invoke the appropriate extension_language_ops.eval_from_control_command | |
342 | method to perform CMD, which is a list of commands in an extension language. | |
343 | ||
344 | This function is what implements, for example: | |
345 | ||
346 | python | |
347 | print 42 | |
348 | end | |
349 | ||
350 | in a GDB script. */ | |
351 | ||
352 | void | |
353 | eval_ext_lang_from_control_command (struct command_line *cmd) | |
354 | { | |
355 | int i; | |
356 | const struct extension_language_defn *extlang; | |
357 | ||
358 | ALL_EXTENSION_LANGUAGES (i, extlang) | |
359 | { | |
360 | if (extlang->cli_control_type == cmd->control_type) | |
361 | { | |
feef67ab DE |
362 | if (extlang->ops != NULL |
363 | && extlang->ops->eval_from_control_command != NULL) | |
6dddc817 DE |
364 | { |
365 | extlang->ops->eval_from_control_command (extlang, cmd); | |
366 | return; | |
367 | } | |
368 | /* The requested extension language is not supported in this GDB. */ | |
369 | throw_ext_lang_unsupported (extlang); | |
370 | } | |
371 | } | |
372 | ||
373 | gdb_assert_not_reached ("unknown extension language in command_line"); | |
374 | } | |
375 | ||
376 | /* Search for and load scripts for OBJFILE written in extension languages. | |
377 | This includes GDB's own scripting language. | |
378 | ||
379 | This function is what implements the loading of OBJFILE-gdb.py and | |
380 | OBJFILE-gdb.gdb. */ | |
381 | ||
382 | void | |
383 | auto_load_ext_lang_scripts_for_objfile (struct objfile *objfile) | |
384 | { | |
385 | int i; | |
386 | const struct extension_language_defn *extlang; | |
387 | ||
388 | extlang = &extension_language_gdb; | |
389 | if (ext_lang_auto_load_enabled (extlang)) | |
390 | auto_load_objfile_script (objfile, extlang); | |
391 | ||
392 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
393 | { | |
394 | if (ext_lang_auto_load_enabled (extlang)) | |
395 | auto_load_objfile_script (objfile, extlang); | |
396 | } | |
397 | } | |
398 | \f | |
399 | /* Interface to type pretty-printers implemented in an extension language. */ | |
400 | ||
401 | /* Call this at the start when preparing to pretty-print a type. | |
402 | The result is a pointer to an opaque object (to the caller) to be passed | |
403 | to apply_ext_lang_type_printers and free_ext_lang_type_printers. | |
404 | ||
405 | We don't know in advance which extension language will provide a | |
406 | pretty-printer for the type, so all are initialized. */ | |
407 | ||
408 | struct ext_lang_type_printers * | |
409 | start_ext_lang_type_printers (void) | |
410 | { | |
411 | struct ext_lang_type_printers *printers | |
412 | = XCNEW (struct ext_lang_type_printers); | |
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, printers); | |
420 | } | |
421 | ||
422 | return printers; | |
423 | } | |
424 | ||
425 | /* Iteratively try the type pretty-printers specified by PRINTERS | |
426 | according to the standard search order (specified by extension_languages), | |
427 | returning the result of the first one that succeeds. | |
428 | If there was an error, or if no printer succeeds, then NULL is returned. */ | |
429 | ||
430 | char * | |
431 | apply_ext_lang_type_printers (struct ext_lang_type_printers *printers, | |
432 | struct type *type) | |
433 | { | |
434 | int i; | |
435 | const struct extension_language_defn *extlang; | |
436 | ||
437 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
438 | { | |
439 | char *result = NULL; | |
440 | enum ext_lang_rc rc; | |
441 | ||
442 | if (extlang->ops->apply_type_printers == NULL) | |
443 | continue; | |
444 | rc = extlang->ops->apply_type_printers (extlang, printers, type, | |
445 | &result); | |
446 | switch (rc) | |
447 | { | |
448 | case EXT_LANG_RC_OK: | |
449 | gdb_assert (result != NULL); | |
450 | return result; | |
451 | case EXT_LANG_RC_ERROR: | |
452 | return NULL; | |
453 | case EXT_LANG_RC_NOP: | |
454 | break; | |
455 | default: | |
456 | gdb_assert_not_reached ("bad return from apply_type_printers"); | |
457 | } | |
458 | } | |
459 | ||
460 | return NULL; | |
461 | } | |
462 | ||
463 | /* Call this after pretty-printing a type to release all memory held | |
464 | by PRINTERS. */ | |
465 | ||
466 | void | |
467 | free_ext_lang_type_printers (struct ext_lang_type_printers *printers) | |
468 | { | |
469 | int i; | |
470 | const struct extension_language_defn *extlang; | |
471 | ||
472 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
473 | { | |
474 | if (extlang->ops->free_type_printers != NULL) | |
475 | extlang->ops->free_type_printers (extlang, printers); | |
476 | } | |
477 | ||
478 | xfree (printers); | |
479 | } | |
480 | \f | |
668e1674 YQ |
481 | /* Try to pretty-print a value of type TYPE located at VAL's contents |
482 | buffer + EMBEDDED_OFFSET, which came from the inferior at address | |
483 | ADDRESS + EMBEDDED_OFFSET, onto stdio stream STREAM according to | |
484 | OPTIONS. | |
485 | VAL is the whole object that came from ADDRESS. | |
6dddc817 DE |
486 | Returns non-zero if the value was successfully pretty-printed. |
487 | ||
488 | Extension languages are tried in the order specified by | |
489 | extension_languages. The first one to provide a pretty-printed | |
490 | value "wins". | |
491 | ||
492 | If an error is encountered in a pretty-printer, no further extension | |
493 | languages are tried. | |
494 | Note: This is different than encountering a memory error trying to read a | |
495 | value for pretty-printing. Here we're referring to, e.g., programming | |
496 | errors that trigger an exception in the extension language. */ | |
497 | ||
498 | int | |
668e1674 | 499 | apply_ext_lang_val_pretty_printer (struct type *type, |
6b850546 | 500 | LONGEST embedded_offset, CORE_ADDR address, |
6dddc817 | 501 | struct ui_file *stream, int recurse, |
668e1674 | 502 | struct value *val, |
6dddc817 DE |
503 | const struct value_print_options *options, |
504 | const struct language_defn *language) | |
505 | { | |
506 | int i; | |
507 | const struct extension_language_defn *extlang; | |
508 | ||
509 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
510 | { | |
511 | enum ext_lang_rc rc; | |
512 | ||
513 | if (extlang->ops->apply_val_pretty_printer == NULL) | |
514 | continue; | |
668e1674 | 515 | rc = extlang->ops->apply_val_pretty_printer (extlang, type, |
6dddc817 DE |
516 | embedded_offset, address, |
517 | stream, recurse, val, | |
518 | options, language); | |
519 | switch (rc) | |
520 | { | |
521 | case EXT_LANG_RC_OK: | |
522 | return 1; | |
523 | case EXT_LANG_RC_ERROR: | |
524 | return 0; | |
525 | case EXT_LANG_RC_NOP: | |
526 | break; | |
527 | default: | |
528 | gdb_assert_not_reached ("bad return from apply_val_pretty_printer"); | |
529 | } | |
530 | } | |
531 | ||
532 | return 0; | |
533 | } | |
534 | ||
535 | /* GDB access to the "frame filter" feature. | |
536 | FRAME is the source frame to start frame-filter invocation. FLAGS is an | |
537 | integer holding the flags for printing. The following elements of | |
538 | the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS: | |
539 | PRINT_LEVEL is a flag indicating whether to print the frame's | |
540 | relative level in the output. PRINT_FRAME_INFO is a flag that | |
541 | indicates whether this function should print the frame | |
542 | information, PRINT_ARGS is a flag that indicates whether to print | |
543 | frame arguments, and PRINT_LOCALS, likewise, with frame local | |
544 | variables. ARGS_TYPE is an enumerator describing the argument | |
545 | format, OUT is the output stream to print. FRAME_LOW is the | |
546 | beginning of the slice of frames to print, and FRAME_HIGH is the | |
547 | upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error, | |
548 | or EXT_LANG_BT_COMPLETED on success. | |
549 | ||
550 | Extension languages are tried in the order specified by | |
551 | extension_languages. The first one to provide a filter "wins". | |
552 | If there is an error (EXT_LANG_BT_ERROR) it is reported immediately | |
553 | rather than trying filters in other extension languages. */ | |
554 | ||
555 | enum ext_lang_bt_status | |
556 | apply_ext_lang_frame_filter (struct frame_info *frame, int flags, | |
557 | enum ext_lang_frame_args args_type, | |
558 | struct ui_out *out, | |
559 | int frame_low, int frame_high) | |
560 | { | |
561 | int i; | |
562 | const struct extension_language_defn *extlang; | |
563 | ||
564 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
565 | { | |
566 | enum ext_lang_bt_status status; | |
567 | ||
568 | if (extlang->ops->apply_frame_filter == NULL) | |
569 | continue; | |
570 | status = extlang->ops->apply_frame_filter (extlang, frame, flags, | |
571 | args_type, out, | |
572 | frame_low, frame_high); | |
573 | /* We use the filters from the first extension language that has | |
574 | applicable filters. Also, an error is reported immediately | |
575 | rather than continue trying. */ | |
576 | if (status != EXT_LANG_BT_NO_FILTERS) | |
577 | return status; | |
578 | } | |
579 | ||
580 | return EXT_LANG_BT_NO_FILTERS; | |
581 | } | |
582 | ||
583 | /* Update values held by the extension language when OBJFILE is discarded. | |
584 | New global types must be created for every such value, which must then be | |
585 | updated to use the new types. | |
586 | The function typically just iterates over all appropriate values and | |
587 | calls preserve_one_value for each one. | |
588 | COPIED_TYPES is used to prevent cycles / duplicates and is passed to | |
589 | preserve_one_value. */ | |
590 | ||
591 | void | |
592 | preserve_ext_lang_values (struct objfile *objfile, htab_t copied_types) | |
593 | { | |
594 | int i; | |
595 | const struct extension_language_defn *extlang; | |
596 | ||
597 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
598 | { | |
599 | if (extlang->ops->preserve_values != NULL) | |
600 | extlang->ops->preserve_values (extlang, objfile, copied_types); | |
601 | } | |
602 | } | |
603 | ||
604 | /* If there is a stop condition implemented in an extension language for | |
605 | breakpoint B, return a pointer to the extension language's definition. | |
606 | Otherwise return NULL. | |
607 | If SKIP_LANG is not EXT_LANG_NONE, skip checking this language. | |
608 | This is for the case where we're setting a new condition: Only one | |
609 | condition is allowed, so when setting a condition for any particular | |
610 | extension language, we need to check if any other extension language | |
611 | already has a condition set. */ | |
612 | ||
613 | const struct extension_language_defn * | |
614 | get_breakpoint_cond_ext_lang (struct breakpoint *b, | |
615 | enum extension_language skip_lang) | |
616 | { | |
617 | int i; | |
618 | const struct extension_language_defn *extlang; | |
619 | ||
620 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
621 | { | |
622 | if (extlang->language != skip_lang | |
623 | && extlang->ops->breakpoint_has_cond != NULL | |
624 | && extlang->ops->breakpoint_has_cond (extlang, b)) | |
625 | return extlang; | |
626 | } | |
627 | ||
628 | return NULL; | |
629 | } | |
630 | ||
631 | /* Return whether a stop condition for breakpoint B says to stop. | |
632 | True is also returned if there is no stop condition for B. */ | |
633 | ||
634 | int | |
635 | breakpoint_ext_lang_cond_says_stop (struct breakpoint *b) | |
636 | { | |
637 | int i; | |
638 | const struct extension_language_defn *extlang; | |
639 | enum ext_lang_bp_stop stop = EXT_LANG_BP_STOP_UNSET; | |
640 | ||
641 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
642 | { | |
643 | /* There is a rule that a breakpoint can have at most one of any of a | |
644 | CLI or extension language condition. However, Python hacks in "finish | |
645 | breakpoints" on top of the "stop" check, so we have to call this for | |
646 | every language, even if we could first determine whether a "stop" | |
647 | method exists. */ | |
648 | if (extlang->ops->breakpoint_cond_says_stop != NULL) | |
649 | { | |
650 | enum ext_lang_bp_stop this_stop | |
651 | = extlang->ops->breakpoint_cond_says_stop (extlang, b); | |
652 | ||
653 | if (this_stop != EXT_LANG_BP_STOP_UNSET) | |
654 | { | |
655 | /* Even though we have to check every extension language, only | |
656 | one of them can return yes/no (because only one of them | |
657 | can have a "stop" condition). */ | |
658 | gdb_assert (stop == EXT_LANG_BP_STOP_UNSET); | |
659 | stop = this_stop; | |
660 | } | |
661 | } | |
662 | } | |
663 | ||
664 | return stop == EXT_LANG_BP_STOP_NO ? 0 : 1; | |
665 | } | |
666 | \f | |
667 | /* ^C/SIGINT support. | |
668 | This requires cooperation with the extension languages so the support | |
669 | is defined here. */ | |
670 | ||
671 | /* This flag tracks quit requests when we haven't called out to an | |
672 | extension language. it also holds quit requests when we transition to | |
673 | an extension language that doesn't have cooperative SIGINT handling. */ | |
674 | static int quit_flag; | |
675 | ||
676 | /* The current extension language we've called out to, or | |
677 | extension_language_gdb if there isn't one. | |
678 | This must be set everytime we call out to an extension language, and reset | |
679 | to the previous value when it returns. Note that the previous value may | |
680 | be a different (or the same) extension language. */ | |
681 | static const struct extension_language_defn *active_ext_lang | |
682 | = &extension_language_gdb; | |
683 | ||
684 | /* Return the currently active extension language. */ | |
685 | ||
686 | const struct extension_language_defn * | |
687 | get_active_ext_lang (void) | |
688 | { | |
689 | return active_ext_lang; | |
690 | } | |
691 | ||
692 | /* Install a SIGINT handler. */ | |
693 | ||
694 | static void | |
695 | install_sigint_handler (const struct signal_handler *handler_state) | |
696 | { | |
697 | gdb_assert (handler_state->handler_saved); | |
698 | ||
699 | signal (SIGINT, handler_state->handler); | |
700 | } | |
701 | ||
702 | /* Install GDB's SIGINT handler, storing the previous version in *PREVIOUS. | |
703 | As a simple optimization, if the previous version was GDB's SIGINT handler | |
704 | then mark the previous handler as not having been saved, and thus it won't | |
705 | be restored. */ | |
706 | ||
707 | static void | |
708 | install_gdb_sigint_handler (struct signal_handler *previous) | |
709 | { | |
710 | /* Save here to simplify comparison. */ | |
a40805d4 | 711 | sighandler_t handle_sigint_for_compare = handle_sigint; |
6dddc817 DE |
712 | |
713 | previous->handler = signal (SIGINT, handle_sigint); | |
714 | if (previous->handler != handle_sigint_for_compare) | |
715 | previous->handler_saved = 1; | |
716 | else | |
717 | previous->handler_saved = 0; | |
718 | } | |
719 | ||
720 | /* Set the currently active extension language to NOW_ACTIVE. | |
721 | The result is a pointer to a malloc'd block of memory to pass to | |
722 | restore_active_ext_lang. | |
723 | ||
724 | N.B. This function must be called every time we call out to an extension | |
725 | language, and the result must be passed to restore_active_ext_lang | |
726 | afterwards. | |
727 | ||
728 | If there is a pending SIGINT it is "moved" to the now active extension | |
729 | language, if it supports cooperative SIGINT handling (i.e., it provides | |
730 | {clear,set,check}_quit_flag methods). If the extension language does not | |
731 | support cooperative SIGINT handling, then the SIGINT is left queued and | |
732 | we require the non-cooperative extension language to call check_quit_flag | |
733 | at appropriate times. | |
734 | It is important for the extension language to call check_quit_flag if it | |
735 | installs its own SIGINT handler to prevent the situation where a SIGINT | |
736 | is queued on entry, extension language code runs for a "long" time possibly | |
737 | serving one or more SIGINTs, and then returns. Upon return, if | |
738 | check_quit_flag is not called, the original SIGINT will be thrown. | |
739 | Non-cooperative extension languages are free to install their own SIGINT | |
740 | handler but the original must be restored upon return, either itself | |
741 | or via restore_active_ext_lang. */ | |
742 | ||
743 | struct active_ext_lang_state * | |
744 | set_active_ext_lang (const struct extension_language_defn *now_active) | |
745 | { | |
746 | struct active_ext_lang_state *previous | |
747 | = XCNEW (struct active_ext_lang_state); | |
748 | ||
749 | previous->ext_lang = active_ext_lang; | |
2f99e8fc | 750 | previous->sigint_handler.handler_saved = 0; |
6dddc817 DE |
751 | active_ext_lang = now_active; |
752 | ||
223ffa71 | 753 | if (target_terminal::is_ours ()) |
2f99e8fc YQ |
754 | { |
755 | /* If the newly active extension language uses cooperative SIGINT | |
756 | handling then ensure GDB's SIGINT handler is installed. */ | |
757 | if (now_active->language == EXT_LANG_GDB | |
758 | || now_active->ops->check_quit_flag != NULL) | |
759 | install_gdb_sigint_handler (&previous->sigint_handler); | |
760 | ||
761 | /* If there's a SIGINT recorded in the cooperative extension languages, | |
762 | move it to the new language, or save it in GDB's global flag if the | |
763 | newly active extension language doesn't use cooperative SIGINT | |
764 | handling. */ | |
765 | if (check_quit_flag ()) | |
766 | set_quit_flag (); | |
767 | } | |
6dddc817 DE |
768 | |
769 | return previous; | |
770 | } | |
771 | ||
772 | /* Restore active extension language from PREVIOUS. */ | |
773 | ||
774 | void | |
775 | restore_active_ext_lang (struct active_ext_lang_state *previous) | |
776 | { | |
6dddc817 DE |
777 | active_ext_lang = previous->ext_lang; |
778 | ||
223ffa71 | 779 | if (target_terminal::is_ours ()) |
2f99e8fc YQ |
780 | { |
781 | /* Restore the previous SIGINT handler if one was saved. */ | |
782 | if (previous->sigint_handler.handler_saved) | |
783 | install_sigint_handler (&previous->sigint_handler); | |
784 | ||
785 | /* If there's a SIGINT recorded in the cooperative extension languages, | |
786 | move it to the new language, or save it in GDB's global flag if the | |
787 | newly active extension language doesn't use cooperative SIGINT | |
788 | handling. */ | |
789 | if (check_quit_flag ()) | |
790 | set_quit_flag (); | |
791 | } | |
6dddc817 DE |
792 | xfree (previous); |
793 | } | |
794 | ||
6dddc817 DE |
795 | /* Set the quit flag. |
796 | This only sets the flag in the currently active extension language. | |
797 | If the currently active extension language does not have cooperative | |
798 | SIGINT handling, then GDB's global flag is set, and it is up to the | |
799 | extension language to call check_quit_flag. The extension language | |
800 | is free to install its own SIGINT handler, but we still need to handle | |
801 | the transition. */ | |
802 | ||
803 | void | |
804 | set_quit_flag (void) | |
805 | { | |
806 | if (active_ext_lang->ops != NULL | |
807 | && active_ext_lang->ops->set_quit_flag != NULL) | |
808 | active_ext_lang->ops->set_quit_flag (active_ext_lang); | |
809 | else | |
f0881b37 PA |
810 | { |
811 | quit_flag = 1; | |
812 | ||
813 | /* Now wake up the event loop, or any interruptible_select. Do | |
814 | this after setting the flag, because signals on Windows | |
815 | actually run on a separate thread, and thus otherwise the | |
816 | main code could be woken up and find quit_flag still | |
817 | clear. */ | |
818 | quit_serial_event_set (); | |
819 | } | |
6dddc817 DE |
820 | } |
821 | ||
822 | /* Return true if the quit flag has been set, false otherwise. | |
823 | Note: The flag is cleared as a side-effect. | |
824 | The flag is checked in all extension languages that support cooperative | |
825 | SIGINT handling, not just the current one. This simplifies transitions. */ | |
826 | ||
827 | int | |
828 | check_quit_flag (void) | |
829 | { | |
830 | int i, result = 0; | |
831 | const struct extension_language_defn *extlang; | |
832 | ||
833 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
834 | { | |
835 | if (extlang->ops->check_quit_flag != NULL) | |
836 | if (extlang->ops->check_quit_flag (extlang) != 0) | |
837 | result = 1; | |
838 | } | |
839 | ||
840 | /* This is written in a particular way to avoid races. */ | |
841 | if (quit_flag) | |
842 | { | |
f0881b37 PA |
843 | /* No longer need to wake up the event loop or any |
844 | interruptible_select. The caller handles the quit | |
845 | request. */ | |
846 | quit_serial_event_clear (); | |
6dddc817 DE |
847 | quit_flag = 0; |
848 | result = 1; | |
849 | } | |
850 | ||
851 | return result; | |
852 | } | |
853 | \f | |
e81e7f5e SC |
854 | /* xmethod support. */ |
855 | ||
856 | /* The xmethod API routines do not have "ext_lang" in the name because | |
857 | the name "xmethod" implies that this routine deals with extension | |
858 | languages. Plus some of the methods take a xmethod_foo * "self/this" | |
859 | arg, not an extension_language_defn * arg. */ | |
860 | ||
861 | /* Returns a new xmethod_worker with EXTLANG and DATA. Space for the | |
862 | result must be freed with free_xmethod_worker. */ | |
863 | ||
864 | struct xmethod_worker * | |
865 | new_xmethod_worker (const struct extension_language_defn *extlang, void *data) | |
866 | { | |
867 | struct xmethod_worker *worker = XCNEW (struct xmethod_worker); | |
868 | ||
869 | worker->extlang = extlang; | |
870 | worker->data = data; | |
871 | worker->value = NULL; | |
872 | ||
873 | return worker; | |
874 | } | |
875 | ||
876 | /* Clones WORKER and returns a new but identical worker. | |
877 | The function get_matching_xmethod_workers (see below), returns a | |
878 | vector of matching workers. If a particular worker is selected by GDB | |
879 | to invoke a method, then this function can help in cloning the | |
880 | selected worker and freeing up the vector via a cleanup. | |
881 | ||
882 | Space for the result must be freed with free_xmethod_worker. */ | |
883 | ||
884 | struct xmethod_worker * | |
885 | clone_xmethod_worker (struct xmethod_worker *worker) | |
886 | { | |
887 | struct xmethod_worker *new_worker; | |
888 | const struct extension_language_defn *extlang = worker->extlang; | |
889 | ||
890 | gdb_assert (extlang->ops->clone_xmethod_worker_data != NULL); | |
891 | ||
892 | new_worker = new_xmethod_worker | |
893 | (extlang, | |
894 | extlang->ops->clone_xmethod_worker_data (extlang, worker->data)); | |
895 | ||
896 | return new_worker; | |
897 | } | |
898 | ||
899 | /* If a method with name METHOD_NAME is to be invoked on an object of type | |
900 | TYPE, then all entension languages are searched for implementations of | |
901 | methods with name METHOD. All matches found are returned as a vector | |
902 | of 'xmethod_worker_ptr' objects. If no matching methods are | |
903 | found, NULL is returned. */ | |
904 | ||
905 | VEC (xmethod_worker_ptr) * | |
906 | get_matching_xmethod_workers (struct type *type, const char *method_name) | |
907 | { | |
908 | VEC (xmethod_worker_ptr) *workers = NULL; | |
909 | int i; | |
910 | const struct extension_language_defn *extlang; | |
911 | ||
912 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
913 | { | |
914 | VEC (xmethod_worker_ptr) *lang_workers, *new_vec; | |
915 | enum ext_lang_rc rc; | |
916 | ||
917 | /* If an extension language does not support xmethods, ignore | |
918 | it. */ | |
919 | if (extlang->ops->get_matching_xmethod_workers == NULL) | |
920 | continue; | |
921 | ||
922 | rc = extlang->ops->get_matching_xmethod_workers (extlang, | |
923 | type, method_name, | |
924 | &lang_workers); | |
925 | if (rc == EXT_LANG_RC_ERROR) | |
926 | { | |
927 | free_xmethod_worker_vec (workers); | |
928 | error (_("Error while looking for matching xmethod workers " | |
929 | "defined in %s."), extlang->capitalized_name); | |
930 | } | |
931 | ||
932 | new_vec = VEC_merge (xmethod_worker_ptr, workers, lang_workers); | |
933 | /* Free only the vectors and not the elements as NEW_VEC still | |
934 | contains them. */ | |
935 | VEC_free (xmethod_worker_ptr, workers); | |
936 | VEC_free (xmethod_worker_ptr, lang_workers); | |
937 | workers = new_vec; | |
938 | } | |
939 | ||
940 | return workers; | |
941 | } | |
942 | ||
943 | /* Return the arg types of the xmethod encapsulated in WORKER. | |
944 | An array of arg types is returned. The length of the array is returned in | |
945 | NARGS. The type of the 'this' object is returned as the first element of | |
946 | array. */ | |
947 | ||
948 | struct type ** | |
949 | get_xmethod_arg_types (struct xmethod_worker *worker, int *nargs) | |
950 | { | |
951 | enum ext_lang_rc rc; | |
952 | struct type **type_array = NULL; | |
953 | const struct extension_language_defn *extlang = worker->extlang; | |
954 | ||
955 | gdb_assert (extlang->ops->get_xmethod_arg_types != NULL); | |
956 | ||
957 | rc = extlang->ops->get_xmethod_arg_types (extlang, worker, nargs, | |
958 | &type_array); | |
959 | if (rc == EXT_LANG_RC_ERROR) | |
960 | { | |
961 | error (_("Error while looking for arg types of a xmethod worker " | |
962 | "defined in %s."), extlang->capitalized_name); | |
963 | } | |
964 | ||
965 | return type_array; | |
966 | } | |
967 | ||
2ce1cdbf DE |
968 | /* Return the type of the result of the xmethod encapsulated in WORKER. |
969 | OBJECT, ARGS, NARGS are the same as for invoke_xmethod. */ | |
970 | ||
971 | struct type * | |
972 | get_xmethod_result_type (struct xmethod_worker *worker, | |
973 | struct value *object, struct value **args, int nargs) | |
974 | { | |
975 | enum ext_lang_rc rc; | |
976 | struct type *result_type; | |
977 | const struct extension_language_defn *extlang = worker->extlang; | |
978 | ||
979 | gdb_assert (extlang->ops->get_xmethod_arg_types != NULL); | |
980 | ||
981 | rc = extlang->ops->get_xmethod_result_type (extlang, worker, | |
982 | object, args, nargs, | |
983 | &result_type); | |
984 | if (rc == EXT_LANG_RC_ERROR) | |
985 | { | |
986 | error (_("Error while fetching result type of an xmethod worker " | |
987 | "defined in %s."), extlang->capitalized_name); | |
988 | } | |
989 | ||
990 | return result_type; | |
991 | } | |
992 | ||
e81e7f5e SC |
993 | /* Invokes the xmethod encapsulated in WORKER and returns the result. |
994 | The method is invoked on OBJ with arguments in the ARGS array. NARGS is | |
995 | the length of the this array. */ | |
996 | ||
997 | struct value * | |
998 | invoke_xmethod (struct xmethod_worker *worker, struct value *obj, | |
999 | struct value **args, int nargs) | |
1000 | { | |
1001 | gdb_assert (worker->extlang->ops->invoke_xmethod != NULL); | |
1002 | ||
1003 | return worker->extlang->ops->invoke_xmethod (worker->extlang, worker, | |
1004 | obj, args, nargs); | |
1005 | } | |
1006 | ||
1007 | /* Frees the xmethod worker WORKER. */ | |
1008 | ||
1009 | void | |
1010 | free_xmethod_worker (struct xmethod_worker *worker) | |
1011 | { | |
1012 | gdb_assert (worker->extlang->ops->free_xmethod_worker_data != NULL); | |
1013 | worker->extlang->ops->free_xmethod_worker_data (worker->extlang, | |
1014 | worker->data); | |
1015 | xfree (worker); | |
1016 | } | |
1017 | ||
1018 | /* Frees a vector of xmethod_workers VEC. */ | |
1019 | ||
1020 | void | |
1021 | free_xmethod_worker_vec (void *vec) | |
1022 | { | |
1023 | int i; | |
1024 | struct xmethod_worker *worker; | |
1025 | VEC (xmethod_worker_ptr) *v = (VEC (xmethod_worker_ptr) *) vec; | |
1026 | ||
1027 | for (i = 0; VEC_iterate (xmethod_worker_ptr, v, i, worker); i++) | |
1028 | free_xmethod_worker (worker); | |
1029 | ||
1030 | VEC_free (xmethod_worker_ptr, v); | |
1031 | } | |
1032 | \f | |
6dddc817 DE |
1033 | /* Called via an observer before gdb prints its prompt. |
1034 | Iterate over the extension languages giving them a chance to | |
1035 | change the prompt. The first one to change the prompt wins, | |
1036 | and no further languages are tried. */ | |
1037 | ||
1038 | static void | |
1039 | ext_lang_before_prompt (const char *current_gdb_prompt) | |
1040 | { | |
1041 | int i; | |
1042 | const struct extension_language_defn *extlang; | |
1043 | ||
1044 | ALL_ENABLED_EXTENSION_LANGUAGES (i, extlang) | |
1045 | { | |
1046 | enum ext_lang_rc rc; | |
1047 | ||
1048 | if (extlang->ops->before_prompt == NULL) | |
1049 | continue; | |
1050 | rc = extlang->ops->before_prompt (extlang, current_gdb_prompt); | |
1051 | switch (rc) | |
1052 | { | |
1053 | case EXT_LANG_RC_OK: | |
1054 | case EXT_LANG_RC_ERROR: | |
1055 | return; | |
1056 | case EXT_LANG_RC_NOP: | |
1057 | break; | |
1058 | default: | |
1059 | gdb_assert_not_reached ("bad return from before_prompt"); | |
1060 | } | |
1061 | } | |
1062 | } | |
1063 | ||
6dddc817 DE |
1064 | void |
1065 | _initialize_extension (void) | |
1066 | { | |
1067 | observer_attach_before_prompt (ext_lang_before_prompt); | |
1068 | } |