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