1 /* General GDB/Guile code.
3 Copyright (C) 2014-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 /* See README file in this directory for implementation notes, coding
21 conventions, et.al. */
24 #include "breakpoint.h"
25 #include "cli/cli-cmds.h"
26 #include "cli/cli-script.h"
27 #include "cli/cli-utils.h"
31 #include "extension-priv.h"
33 #include "gdbsupport/version.h"
36 #include "guile-internal.h"
40 /* The Guile version we're using.
41 We *could* use the macros in libguile/version.h but that would preclude
42 handling the user switching in a different version with, e.g.,
43 LD_LIBRARY_PATH (using a different version than what gdb was compiled with
44 is not something to be done lightly, but can be useful). */
45 int gdbscm_guile_major_version
;
46 int gdbscm_guile_minor_version
;
47 int gdbscm_guile_micro_version
;
50 /* The guile subdirectory within gdb's data-directory. */
51 static const char *guile_datadir
;
54 /* Declared constants and enum for guile exception printing. */
55 const char gdbscm_print_excp_none
[] = "none";
56 const char gdbscm_print_excp_full
[] = "full";
57 const char gdbscm_print_excp_message
[] = "message";
59 /* "set guile print-stack" choices. */
60 static const char *const guile_print_excp_enums
[] =
62 gdbscm_print_excp_none
,
63 gdbscm_print_excp_full
,
64 gdbscm_print_excp_message
,
68 /* The exception printing variable. 'full' if we want to print the
69 error message and stack, 'none' if we want to print nothing, and
70 'message' if we only want to print the error message. 'message' is
72 const char *gdbscm_print_excp
= gdbscm_print_excp_message
;
77 static void gdbscm_finish_initialization
78 (const struct extension_language_defn
*);
79 static int gdbscm_initialized (const struct extension_language_defn
*);
80 static void gdbscm_eval_from_control_command
81 (const struct extension_language_defn
*, struct command_line
*);
82 static script_sourcer_func gdbscm_source_script
;
84 int gdb_scheme_initialized
;
86 /* Symbol for setting documentation strings. */
87 SCM gdbscm_documentation_symbol
;
89 /* Keywords used by various functions. */
90 static SCM from_tty_keyword
;
91 static SCM to_string_keyword
;
93 /* The name of the various modules (without the surrounding parens). */
94 const char gdbscm_module_name
[] = "gdb";
95 const char gdbscm_init_module_name
[] = "gdb";
97 /* The name of the bootstrap file. */
98 static const char boot_scm_filename
[] = "boot.scm";
100 /* The interface between gdb proper and loading of python scripts. */
102 static const struct extension_language_script_ops guile_extension_script_ops
=
104 gdbscm_source_script
,
105 gdbscm_source_objfile_script
,
106 gdbscm_execute_objfile_script
,
107 gdbscm_auto_load_enabled
110 /* The interface between gdb proper and guile scripting. */
112 static const struct extension_language_ops guile_extension_ops
=
114 gdbscm_finish_initialization
,
117 gdbscm_eval_from_control_command
,
119 NULL
, /* gdbscm_start_type_printers, */
120 NULL
, /* gdbscm_apply_type_printers, */
121 NULL
, /* gdbscm_free_type_printers, */
123 gdbscm_apply_val_pretty_printer
,
125 NULL
, /* gdbscm_apply_frame_filter, */
127 gdbscm_preserve_values
,
129 gdbscm_breakpoint_has_cond
,
130 gdbscm_breakpoint_cond_says_stop
,
132 NULL
, /* gdbscm_check_quit_flag, */
133 NULL
, /* gdbscm_set_quit_flag, */
137 /* The main struct describing GDB's interface to the Guile
138 extension language. */
139 extern const struct extension_language_defn extension_language_guile
=
151 &guile_extension_script_ops
,
160 /* Implementation of the gdb "guile-repl" command. */
163 guile_repl_command (const char *arg
, int from_tty
)
165 scoped_restore restore_async
= make_scoped_restore (¤t_ui
->async
, 0);
167 arg
= skip_spaces (arg
);
169 /* This explicitly rejects any arguments for now.
170 "It is easier to relax a restriction than impose one after the fact."
171 We would *like* to be able to pass arguments to the interactive shell
172 but that's not what python-interactive does. Until there is time to
173 sort it out, we forbid arguments. */
176 error (_("guile-repl currently does not take any arguments."));
180 gdbscm_enter_repl ();
184 /* Implementation of the gdb "guile" command.
185 Note: Contrary to the Python version this displays the result.
186 Have to see which is better.
188 TODO: Add the result to Guile's history? */
191 guile_command (const char *arg
, int from_tty
)
193 scoped_restore restore_async
= make_scoped_restore (¤t_ui
->async
, 0);
195 arg
= skip_spaces (arg
);
199 gdb::unique_xmalloc_ptr
<char> msg
= gdbscm_safe_eval_string (arg
, 1);
202 error ("%s", msg
.get ());
206 counted_command_line l
= get_command_line (guile_control
, "");
208 execute_control_command_untraced (l
.get ());
212 /* Given a command_line, return a command string suitable for passing
213 to Guile. Lines in the string are separated by newlines. The return
214 value is allocated using xmalloc and the caller is responsible for
218 compute_scheme_string (struct command_line
*l
)
220 struct command_line
*iter
;
225 for (iter
= l
; iter
; iter
= iter
->next
)
226 size
+= strlen (iter
->line
) + 1;
228 script
= (char *) xmalloc (size
+ 1);
230 for (iter
= l
; iter
; iter
= iter
->next
)
232 int len
= strlen (iter
->line
);
234 strcpy (&script
[here
], iter
->line
);
236 script
[here
++] = '\n';
242 /* Take a command line structure representing a "guile" command, and
243 evaluate its body using the Guile interpreter.
244 This is the extension_language_ops.eval_from_control_command "method". */
247 gdbscm_eval_from_control_command
248 (const struct extension_language_defn
*extlang
, struct command_line
*cmd
)
252 if (cmd
->body_list_1
!= nullptr)
253 error (_("Invalid \"guile\" block structure."));
255 script
= compute_scheme_string (cmd
->body_list_0
.get ());
256 gdb::unique_xmalloc_ptr
<char> msg
= gdbscm_safe_eval_string (script
, 0);
259 error ("%s", msg
.get ());
262 /* Read a file as Scheme code.
263 This is the extension_language_script_ops.script_sourcer "method".
264 FILE is the file to run. FILENAME is name of the file FILE.
265 This does not throw any errors. If an exception occurs an error message
269 gdbscm_source_script (const struct extension_language_defn
*extlang
,
270 FILE *file
, const char *filename
)
272 char *msg
= gdbscm_safe_source_script (filename
);
276 fprintf_filtered (gdb_stderr
, "%s\n", msg
);
281 /* (execute string [#:from-tty boolean] [#:to-string boolean])
282 A Scheme function which evaluates a string using the gdb CLI. */
285 gdbscm_execute_gdb_command (SCM command_scm
, SCM rest
)
287 int from_tty_arg_pos
= -1, to_string_arg_pos
= -1;
288 int from_tty
= 0, to_string
= 0;
289 const SCM keywords
[] = { from_tty_keyword
, to_string_keyword
, SCM_BOOL_F
};
292 gdbscm_parse_function_args (FUNC_NAME
, SCM_ARG1
, keywords
, "s#tt",
293 command_scm
, &command
, rest
,
294 &from_tty_arg_pos
, &from_tty
,
295 &to_string_arg_pos
, &to_string
);
297 return gdbscm_wrap ([=]
299 gdb::unique_xmalloc_ptr
<char> command_holder (command
);
300 std::string to_string_res
;
302 scoped_restore restore_async
= make_scoped_restore (¤t_ui
->async
,
305 scoped_restore preventer
= prevent_dont_repeat ();
307 to_string_res
= execute_command_to_string (command
, from_tty
, false);
309 execute_command (command
, from_tty
);
311 /* Do any commands attached to breakpoint we stopped at. */
312 bpstat_do_actions ();
315 return gdbscm_scm_from_c_string (to_string_res
.c_str ());
316 return SCM_UNSPECIFIED
;
320 /* (data-directory) -> string */
323 gdbscm_data_directory (void)
325 return gdbscm_scm_from_c_string (gdb_datadir
.c_str ());
328 /* (guile-data-directory) -> string */
331 gdbscm_guile_data_directory (void)
333 return gdbscm_scm_from_c_string (guile_datadir
);
336 /* (gdb-version) -> string */
339 gdbscm_gdb_version (void)
341 return gdbscm_scm_from_c_string (version
);
344 /* (host-config) -> string */
347 gdbscm_host_config (void)
349 return gdbscm_scm_from_c_string (host_name
);
352 /* (target-config) -> string */
355 gdbscm_target_config (void)
357 return gdbscm_scm_from_c_string (target_name
);
360 #else /* ! HAVE_GUILE */
362 /* Dummy implementation of the gdb "guile-repl" and "guile"
366 guile_repl_command (const char *arg
, int from_tty
)
368 arg
= skip_spaces (arg
);
370 error (_("guile-repl currently does not take any arguments."));
371 error (_("Guile scripting is not supported in this copy of GDB."));
375 guile_command (const char *arg
, int from_tty
)
377 arg
= skip_spaces (arg
);
379 error (_("Guile scripting is not supported in this copy of GDB."));
382 /* Even if Guile isn't enabled, we still have to slurp the
383 command list to the corresponding "end". */
384 counted_command_line l
= get_command_line (guile_control
, "");
386 execute_control_command_untraced (l
.get ());
390 #endif /* ! HAVE_GUILE */
392 /* Lists for 'set,show,info guile' commands. */
394 static struct cmd_list_element
*set_guile_list
;
395 static struct cmd_list_element
*show_guile_list
;
396 static struct cmd_list_element
*info_guile_list
;
398 /* Function for use by 'set guile' prefix command. */
401 set_guile_command (const char *args
, int from_tty
)
403 help_list (set_guile_list
, "set guile ", all_commands
, gdb_stdout
);
406 /* Function for use by 'show guile' prefix command. */
409 show_guile_command (const char *args
, int from_tty
)
411 cmd_show_list (show_guile_list
, from_tty
, "");
414 /* The "info scheme" command is defined as a prefix, with
415 allow_unknown 0. Therefore, its own definition is called only for
416 "info scheme" with no args. */
419 info_guile_command (const char *args
, int from_tty
)
421 printf_unfiltered (_("\"info guile\" must be followed"
422 " by the name of an info command.\n"));
423 help_list (info_guile_list
, "info guile ", all_commands
, gdb_stdout
);
426 /* Initialization. */
430 static const scheme_function misc_guile_functions
[] =
432 { "execute", 1, 0, 1, as_a_scm_t_subr (gdbscm_execute_gdb_command
),
434 Execute the given GDB command.\n\
436 Arguments: string [#:to-string boolean] [#:from-tty boolean]\n\
437 If #:from-tty is true then the command executes as if entered\n\
438 from the keyboard. The default is false (#f).\n\
439 If #:to-string is true then the result is returned as a string.\n\
440 Otherwise output is sent to the current output port,\n\
441 which is the default.\n\
442 Returns: The result of the command if #:to-string is true.\n\
443 Otherwise returns unspecified." },
445 { "data-directory", 0, 0, 0, as_a_scm_t_subr (gdbscm_data_directory
),
447 Return the name of GDB's data directory." },
449 { "guile-data-directory", 0, 0, 0,
450 as_a_scm_t_subr (gdbscm_guile_data_directory
),
452 Return the name of the Guile directory within GDB's data directory." },
454 { "gdb-version", 0, 0, 0, as_a_scm_t_subr (gdbscm_gdb_version
),
456 Return GDB's version string." },
458 { "host-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_host_config
),
460 Return the name of the host configuration." },
462 { "target-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_target_config
),
464 Return the name of the target configuration." },
469 /* Load BOOT_SCM_FILE, the first Scheme file that gets loaded. */
472 boot_guile_support (void *boot_scm_file
)
474 /* Load boot.scm without compiling it (there's no need to compile it).
475 The other files should have been compiled already, and boot.scm is
476 expected to adjust '%load-compiled-path' accordingly. If they haven't
477 been compiled, Guile will auto-compile them. The important thing to keep
478 in mind is that there's a >= 100x speed difference between compiled and
479 non-compiled files. */
480 return scm_c_primitive_load ((const char *) boot_scm_file
);
483 /* Return non-zero if ARGS has the "standard" format for throw args.
484 The standard format is:
485 (function format-string (format-string-args-list) ...).
486 FUNCTION is #f if no function was recorded. */
489 standard_throw_args_p (SCM args
)
491 if (gdbscm_is_true (scm_list_p (args
))
492 && scm_ilength (args
) >= 3)
494 /* The function in which the error occurred. */
495 SCM arg0
= scm_list_ref (args
, scm_from_int (0));
496 /* The format string. */
497 SCM arg1
= scm_list_ref (args
, scm_from_int (1));
498 /* The arguments of the format string. */
499 SCM arg2
= scm_list_ref (args
, scm_from_int (2));
501 if ((scm_is_string (arg0
) || gdbscm_is_false (arg0
))
502 && scm_is_string (arg1
)
503 && gdbscm_is_true (scm_list_p (arg2
)))
510 /* Print the error recorded in a "standard" throw args. */
513 print_standard_throw_error (SCM args
)
515 /* The function in which the error occurred. */
516 SCM arg0
= scm_list_ref (args
, scm_from_int (0));
517 /* The format string. */
518 SCM arg1
= scm_list_ref (args
, scm_from_int (1));
519 /* The arguments of the format string. */
520 SCM arg2
= scm_list_ref (args
, scm_from_int (2));
522 /* ARG0 is #f if no function was recorded. */
523 if (gdbscm_is_true (arg0
))
525 scm_simple_format (scm_current_error_port (),
526 scm_from_latin1_string (_("Error in function ~s:~%")),
529 scm_simple_format (scm_current_error_port (), arg1
, arg2
);
532 /* Print the error message recorded in KEY, ARGS, the arguments to throw.
533 Normally we let Scheme print the error message.
534 This function is used when Scheme initialization fails.
535 We can still use the Scheme C API though. */
538 print_throw_error (SCM key
, SCM args
)
540 /* IWBN to call gdbscm_print_exception_with_stack here, but Guile didn't
541 boot successfully so play it safe and avoid it. The "format string" and
542 its args are embedded in ARGS, but the content of ARGS depends on KEY.
543 Make sure ARGS has the expected canonical content before trying to use
545 if (standard_throw_args_p (args
))
546 print_standard_throw_error (args
);
549 scm_simple_format (scm_current_error_port (),
550 scm_from_latin1_string (_("Throw to key `~a' with args `~s'.~%")),
551 scm_list_2 (key
, args
));
555 /* Handle an exception thrown while loading BOOT_SCM_FILE. */
558 handle_boot_error (void *boot_scm_file
, SCM key
, SCM args
)
560 fprintf_unfiltered (gdb_stderr
, ("Exception caught while booting Guile.\n"));
562 print_throw_error (key
, args
);
564 fprintf_unfiltered (gdb_stderr
, "\n");
565 warning (_("Could not complete Guile gdb module initialization from:\n"
567 "Limited Guile support is available.\n"
568 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
569 (const char *) boot_scm_file
);
571 return SCM_UNSPECIFIED
;
574 /* Load gdb/boot.scm, the Scheme side of GDB/Guile support.
575 Note: This function assumes it's called within the gdb module. */
578 initialize_scheme_side (void)
582 guile_datadir
= concat (gdb_datadir
.c_str (), SLASH_STRING
, "guile",
584 boot_scm_path
= concat (guile_datadir
, SLASH_STRING
, "gdb",
585 SLASH_STRING
, boot_scm_filename
, (char *) NULL
);
587 scm_c_catch (SCM_BOOL_T
, boot_guile_support
, boot_scm_path
,
588 handle_boot_error
, boot_scm_path
, NULL
, NULL
);
590 xfree (boot_scm_path
);
593 /* Install the gdb scheme module.
594 The result is a boolean indicating success.
595 If initializing the gdb module fails an error message is printed.
596 Note: This function runs in the context of the gdb module. */
599 initialize_gdb_module (void *data
)
601 /* Computing these is a pain, so only do it once.
602 Also, do it here and save the result so that obtaining the values
604 gdbscm_guile_major_version
= gdbscm_scm_string_to_int (scm_major_version ());
605 gdbscm_guile_minor_version
= gdbscm_scm_string_to_int (scm_minor_version ());
606 gdbscm_guile_micro_version
= gdbscm_scm_string_to_int (scm_micro_version ());
608 /* The documentation symbol needs to be defined before any calls to
609 gdbscm_define_{variables,functions}. */
610 gdbscm_documentation_symbol
= scm_from_latin1_symbol ("documentation");
612 /* The smob and exception support must be initialized early. */
613 gdbscm_initialize_smobs ();
614 gdbscm_initialize_exceptions ();
616 /* The rest are initialized in alphabetical order. */
617 gdbscm_initialize_arches ();
618 gdbscm_initialize_auto_load ();
619 gdbscm_initialize_blocks ();
620 gdbscm_initialize_breakpoints ();
621 gdbscm_initialize_commands ();
622 gdbscm_initialize_disasm ();
623 gdbscm_initialize_frames ();
624 gdbscm_initialize_iterators ();
625 gdbscm_initialize_lazy_strings ();
626 gdbscm_initialize_math ();
627 gdbscm_initialize_objfiles ();
628 gdbscm_initialize_parameters ();
629 gdbscm_initialize_ports ();
630 gdbscm_initialize_pretty_printers ();
631 gdbscm_initialize_pspaces ();
632 gdbscm_initialize_strings ();
633 gdbscm_initialize_symbols ();
634 gdbscm_initialize_symtabs ();
635 gdbscm_initialize_types ();
636 gdbscm_initialize_values ();
638 gdbscm_define_functions (misc_guile_functions
, 1);
640 from_tty_keyword
= scm_from_latin1_keyword ("from-tty");
641 to_string_keyword
= scm_from_latin1_keyword ("to-string");
643 initialize_scheme_side ();
645 gdb_scheme_initialized
= 1;
648 /* Utility to call scm_c_define_module+initialize_gdb_module from
649 within scm_with_guile. */
652 call_initialize_gdb_module (void *data
)
654 /* Most of the initialization is done by initialize_gdb_module.
655 It is called via scm_c_define_module so that the initialization is
656 performed within the desired module. */
657 scm_c_define_module (gdbscm_module_name
, initialize_gdb_module
, NULL
);
659 #if HAVE_GUILE_MANUAL_FINALIZATION
660 scm_run_finalizers ();
666 /* A callback to finish Guile initialization after gdb has finished all its
668 This is the extension_language_ops.finish_initialization "method". */
671 gdbscm_finish_initialization (const struct extension_language_defn
*extlang
)
673 /* Restore the environment to the user interaction one. */
674 scm_set_current_module (scm_interaction_environment ());
677 /* The extension_language_ops.initialized "method". */
680 gdbscm_initialized (const struct extension_language_defn
*extlang
)
682 return gdb_scheme_initialized
;
685 /* Enable or disable Guile backtraces. */
688 gdbscm_set_backtrace (int enable
)
690 static const char disable_bt
[] = "(debug-disable 'backtrace)";
691 static const char enable_bt
[] = "(debug-enable 'backtrace)";
694 gdbscm_safe_eval_string (enable_bt
, 0);
696 gdbscm_safe_eval_string (disable_bt
, 0);
699 #endif /* HAVE_GUILE */
702 cmd_list_element
*guile_cmd_element
= nullptr;
704 /* Install the various gdb commands used by Guile. */
707 install_gdb_commands (void)
709 add_com ("guile-repl", class_obscure
,
713 Start an interactive Guile prompt.\n\
715 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
717 #else /* HAVE_GUILE */
719 Start a Guile interactive prompt.\n\
721 Guile scripting is not supported in this copy of GDB.\n\
722 This command is only a placeholder.")
723 #endif /* HAVE_GUILE */
725 add_com_alias ("gr", "guile-repl", class_obscure
, 1);
727 /* Since "help guile" is easy to type, and intuitive, we add general help
728 in using GDB+Guile to this command. */
729 guile_cmd_element
= add_com ("guile", class_obscure
, guile_command
,
732 Evaluate one or more Guile expressions.\n\
734 The expression(s) can be given as an argument, for instance:\n\
736 guile (display 23)\n\
738 The result of evaluating the last expression is printed.\n\
740 If no argument is given, the following lines are read and passed\n\
741 to Guile for evaluation. Type a line containing \"end\" to indicate\n\
742 the end of the set of expressions.\n\
744 The Guile GDB module must first be imported before it can be used.\n\
746 (gdb) guile (use-modules (gdb))\n\
747 or if you want to import the (gdb) module with a prefix, use:\n\
748 (gdb) guile (use-modules ((gdb) #:renamer (symbol-prefix-proc 'gdb:)))\n\
750 The Guile interactive session, started with the \"guile-repl\"\n\
751 command, provides extensive help and apropos capabilities.\n\
752 Type \",help\" once in a Guile interactive session.")
753 #else /* HAVE_GUILE */
755 Evaluate a Guile expression.\n\
757 Guile scripting is not supported in this copy of GDB.\n\
758 This command is only a placeholder.")
759 #endif /* HAVE_GUILE */
761 add_com_alias ("gu", "guile", class_obscure
, 1);
763 add_prefix_cmd ("guile", class_obscure
, set_guile_command
,
764 _("Prefix command for Guile preference settings."),
765 &set_guile_list
, "set guile ", 0,
767 add_alias_cmd ("gu", "guile", class_obscure
, 1, &setlist
);
769 add_prefix_cmd ("guile", class_obscure
, show_guile_command
,
770 _("Prefix command for Guile preference settings."),
771 &show_guile_list
, "show guile ", 0,
773 add_alias_cmd ("gu", "guile", class_obscure
, 1, &showlist
);
775 add_prefix_cmd ("guile", class_obscure
, info_guile_command
,
776 _("Prefix command for Guile info displays."),
777 &info_guile_list
, "info guile ", 0,
779 add_info_alias ("gu", "guile", 1);
781 /* The name "print-stack" is carried over from Python.
782 A better name is "print-exception". */
783 add_setshow_enum_cmd ("print-stack", no_class
, guile_print_excp_enums
,
784 &gdbscm_print_excp
, _("\
785 Set mode for Guile exception printing on error."), _("\
786 Show the mode of Guile exception printing on error."), _("\
787 none == no stack or message will be printed.\n\
788 full == a message and a stack will be printed.\n\
789 message == an error message without a stack will be printed."),
791 &set_guile_list
, &show_guile_list
);
795 _initialize_guile (void)
797 install_gdb_commands ();
801 #ifdef HAVE_SIGPROCMASK
802 sigset_t sigchld_mask
, prev_mask
;
805 /* The Python support puts the C side in module "_gdb", leaving the Python
806 side to define module "gdb" which imports "_gdb". There is evidently no
807 similar convention in Guile so we skip this. */
809 #if HAVE_GUILE_MANUAL_FINALIZATION
810 /* Our SMOB free functions are not thread-safe, as GDB itself is not
811 intended to be thread-safe. Disable automatic finalization so that
812 finalizers aren't run in other threads. */
813 scm_set_automatic_finalization_enabled (0);
816 #ifdef HAVE_SIGPROCMASK
817 /* Before we initialize Guile, block SIGCHLD.
818 This is done so that all threads created during Guile initialization
819 have SIGCHLD blocked. PR 17247.
820 Really libgc and Guile should do this, but we need to work with
822 sigemptyset (&sigchld_mask
);
823 sigaddset (&sigchld_mask
, SIGCHLD
);
824 sigprocmask (SIG_BLOCK
, &sigchld_mask
, &prev_mask
);
827 /* scm_with_guile is the most portable way to initialize Guile.
828 Plus we need to initialize the Guile support while in Guile mode
829 (e.g., called from within a call to scm_with_guile). */
830 scm_with_guile (call_initialize_gdb_module
, NULL
);
832 #ifdef HAVE_SIGPROCMASK
833 sigprocmask (SIG_SETMASK
, &prev_mask
, NULL
);
836 /* Set Guile's backtrace to match the "set guile print-stack" default.
837 [N.B. The two settings are still separate.]
838 But only do this after we've initialized Guile, it's nice to see a
839 backtrace if there's an error during initialization.
840 OTOH, if the error is that gdb/init.scm wasn't found because gdb is
841 being run from the build tree, the backtrace is more noise than signal.
843 gdbscm_set_backtrace (0);