870 lines
25 KiB
C
870 lines
25 KiB
C
/* General GDB/Guile code.
|
||
|
||
Copyright (C) 2014-2018 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
/* See README file in this directory for implementation notes, coding
|
||
conventions, et.al. */
|
||
|
||
#include "defs.h"
|
||
#include "breakpoint.h"
|
||
#include "cli/cli-cmds.h"
|
||
#include "cli/cli-script.h"
|
||
#include "cli/cli-utils.h"
|
||
#include "command.h"
|
||
#include "gdbcmd.h"
|
||
#include "top.h"
|
||
#include "extension-priv.h"
|
||
#include "utils.h"
|
||
#include "version.h"
|
||
#ifdef HAVE_GUILE
|
||
#include "guile.h"
|
||
#include "guile-internal.h"
|
||
#endif
|
||
#include <signal.h>
|
||
|
||
/* The Guile version we're using.
|
||
We *could* use the macros in libguile/version.h but that would preclude
|
||
handling the user switching in a different version with, e.g.,
|
||
LD_LIBRARY_PATH (using a different version than what gdb was compiled with
|
||
is not something to be done lightly, but can be useful). */
|
||
int gdbscm_guile_major_version;
|
||
int gdbscm_guile_minor_version;
|
||
int gdbscm_guile_micro_version;
|
||
|
||
/* The guile subdirectory within gdb's data-directory. */
|
||
static const char *guile_datadir;
|
||
|
||
/* Declared constants and enum for guile exception printing. */
|
||
const char gdbscm_print_excp_none[] = "none";
|
||
const char gdbscm_print_excp_full[] = "full";
|
||
const char gdbscm_print_excp_message[] = "message";
|
||
|
||
/* "set guile print-stack" choices. */
|
||
static const char *const guile_print_excp_enums[] =
|
||
{
|
||
gdbscm_print_excp_none,
|
||
gdbscm_print_excp_full,
|
||
gdbscm_print_excp_message,
|
||
NULL
|
||
};
|
||
|
||
/* The exception printing variable. 'full' if we want to print the
|
||
error message and stack, 'none' if we want to print nothing, and
|
||
'message' if we only want to print the error message. 'message' is
|
||
the default. */
|
||
const char *gdbscm_print_excp = gdbscm_print_excp_message;
|
||
|
||
#ifdef HAVE_GUILE
|
||
/* Forward decls, these are defined later. */
|
||
extern const struct extension_language_script_ops guile_extension_script_ops;
|
||
extern const struct extension_language_ops guile_extension_ops;
|
||
#endif
|
||
|
||
/* The main struct describing GDB's interface to the Guile
|
||
extension language. */
|
||
extern const struct extension_language_defn extension_language_guile =
|
||
{
|
||
EXT_LANG_GUILE,
|
||
"guile",
|
||
"Guile",
|
||
|
||
".scm",
|
||
"-gdb.scm",
|
||
|
||
guile_control,
|
||
|
||
#ifdef HAVE_GUILE
|
||
&guile_extension_script_ops,
|
||
&guile_extension_ops
|
||
#else
|
||
NULL,
|
||
NULL
|
||
#endif
|
||
};
|
||
|
||
#ifdef HAVE_GUILE
|
||
|
||
static void gdbscm_finish_initialization
|
||
(const struct extension_language_defn *);
|
||
static int gdbscm_initialized (const struct extension_language_defn *);
|
||
static void gdbscm_eval_from_control_command
|
||
(const struct extension_language_defn *, struct command_line *);
|
||
static script_sourcer_func gdbscm_source_script;
|
||
|
||
int gdb_scheme_initialized;
|
||
|
||
/* Symbol for setting documentation strings. */
|
||
SCM gdbscm_documentation_symbol;
|
||
|
||
/* Keywords used by various functions. */
|
||
static SCM from_tty_keyword;
|
||
static SCM to_string_keyword;
|
||
|
||
/* The name of the various modules (without the surrounding parens). */
|
||
const char gdbscm_module_name[] = "gdb";
|
||
const char gdbscm_init_module_name[] = "gdb";
|
||
|
||
/* The name of the bootstrap file. */
|
||
static const char boot_scm_filename[] = "boot.scm";
|
||
|
||
/* The interface between gdb proper and loading of python scripts. */
|
||
|
||
const struct extension_language_script_ops guile_extension_script_ops =
|
||
{
|
||
gdbscm_source_script,
|
||
gdbscm_source_objfile_script,
|
||
gdbscm_execute_objfile_script,
|
||
gdbscm_auto_load_enabled
|
||
};
|
||
|
||
/* The interface between gdb proper and guile scripting. */
|
||
|
||
const struct extension_language_ops guile_extension_ops =
|
||
{
|
||
gdbscm_finish_initialization,
|
||
gdbscm_initialized,
|
||
|
||
gdbscm_eval_from_control_command,
|
||
|
||
NULL, /* gdbscm_start_type_printers, */
|
||
NULL, /* gdbscm_apply_type_printers, */
|
||
NULL, /* gdbscm_free_type_printers, */
|
||
|
||
gdbscm_apply_val_pretty_printer,
|
||
|
||
NULL, /* gdbscm_apply_frame_filter, */
|
||
|
||
gdbscm_preserve_values,
|
||
|
||
gdbscm_breakpoint_has_cond,
|
||
gdbscm_breakpoint_cond_says_stop,
|
||
|
||
NULL, /* gdbscm_check_quit_flag, */
|
||
NULL, /* gdbscm_set_quit_flag, */
|
||
};
|
||
|
||
/* Implementation of the gdb "guile-repl" command. */
|
||
|
||
static void
|
||
guile_repl_command (const char *arg, int from_tty)
|
||
{
|
||
scoped_restore restore_async = make_scoped_restore (¤t_ui->async, 0);
|
||
|
||
arg = skip_spaces (arg);
|
||
|
||
/* This explicitly rejects any arguments for now.
|
||
"It is easier to relax a restriction than impose one after the fact."
|
||
We would *like* to be able to pass arguments to the interactive shell
|
||
but that's not what python-interactive does. Until there is time to
|
||
sort it out, we forbid arguments. */
|
||
|
||
if (arg && *arg)
|
||
error (_("guile-repl currently does not take any arguments."));
|
||
else
|
||
{
|
||
dont_repeat ();
|
||
gdbscm_enter_repl ();
|
||
}
|
||
}
|
||
|
||
/* Implementation of the gdb "guile" command.
|
||
Note: Contrary to the Python version this displays the result.
|
||
Have to see which is better.
|
||
|
||
TODO: Add the result to Guile's history? */
|
||
|
||
static void
|
||
guile_command (const char *arg, int from_tty)
|
||
{
|
||
scoped_restore restore_async = make_scoped_restore (¤t_ui->async, 0);
|
||
|
||
arg = skip_spaces (arg);
|
||
|
||
if (arg && *arg)
|
||
{
|
||
char *msg = gdbscm_safe_eval_string (arg, 1);
|
||
|
||
if (msg != NULL)
|
||
{
|
||
/* It is ok that this is a "dangling cleanup" because we
|
||
throw immediately. */
|
||
make_cleanup (xfree, msg);
|
||
error ("%s", msg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
counted_command_line l = get_command_line (guile_control, "");
|
||
|
||
execute_control_command_untraced (l.get ());
|
||
}
|
||
}
|
||
|
||
/* Given a command_line, return a command string suitable for passing
|
||
to Guile. Lines in the string are separated by newlines. The return
|
||
value is allocated using xmalloc and the caller is responsible for
|
||
freeing it. */
|
||
|
||
static char *
|
||
compute_scheme_string (struct command_line *l)
|
||
{
|
||
struct command_line *iter;
|
||
char *script = NULL;
|
||
int size = 0;
|
||
int here;
|
||
|
||
for (iter = l; iter; iter = iter->next)
|
||
size += strlen (iter->line) + 1;
|
||
|
||
script = (char *) xmalloc (size + 1);
|
||
here = 0;
|
||
for (iter = l; iter; iter = iter->next)
|
||
{
|
||
int len = strlen (iter->line);
|
||
|
||
strcpy (&script[here], iter->line);
|
||
here += len;
|
||
script[here++] = '\n';
|
||
}
|
||
script[here] = '\0';
|
||
return script;
|
||
}
|
||
|
||
/* Take a command line structure representing a "guile" command, and
|
||
evaluate its body using the Guile interpreter.
|
||
This is the extension_language_ops.eval_from_control_command "method". */
|
||
|
||
static void
|
||
gdbscm_eval_from_control_command
|
||
(const struct extension_language_defn *extlang, struct command_line *cmd)
|
||
{
|
||
char *script, *msg;
|
||
struct cleanup *cleanup;
|
||
|
||
if (cmd->body_list_1 != nullptr)
|
||
error (_("Invalid \"guile\" block structure."));
|
||
|
||
cleanup = make_cleanup (null_cleanup, NULL);
|
||
|
||
script = compute_scheme_string (cmd->body_list_0.get ());
|
||
msg = gdbscm_safe_eval_string (script, 0);
|
||
xfree (script);
|
||
if (msg != NULL)
|
||
{
|
||
make_cleanup (xfree, msg);
|
||
error ("%s", msg);
|
||
}
|
||
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
/* Read a file as Scheme code.
|
||
This is the extension_language_script_ops.script_sourcer "method".
|
||
FILE is the file to run. FILENAME is name of the file FILE.
|
||
This does not throw any errors. If an exception occurs an error message
|
||
is printed. */
|
||
|
||
static void
|
||
gdbscm_source_script (const struct extension_language_defn *extlang,
|
||
FILE *file, const char *filename)
|
||
{
|
||
char *msg = gdbscm_safe_source_script (filename);
|
||
|
||
if (msg != NULL)
|
||
{
|
||
fprintf_filtered (gdb_stderr, "%s\n", msg);
|
||
xfree (msg);
|
||
}
|
||
}
|
||
|
||
/* (execute string [#:from-tty boolean] [#:to-string boolean])
|
||
A Scheme function which evaluates a string using the gdb CLI. */
|
||
|
||
static SCM
|
||
gdbscm_execute_gdb_command (SCM command_scm, SCM rest)
|
||
{
|
||
int from_tty_arg_pos = -1, to_string_arg_pos = -1;
|
||
int from_tty = 0, to_string = 0;
|
||
const SCM keywords[] = { from_tty_keyword, to_string_keyword, SCM_BOOL_F };
|
||
char *command;
|
||
struct cleanup *cleanups;
|
||
struct gdb_exception except = exception_none;
|
||
|
||
gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, keywords, "s#tt",
|
||
command_scm, &command, rest,
|
||
&from_tty_arg_pos, &from_tty,
|
||
&to_string_arg_pos, &to_string);
|
||
|
||
/* Note: The contents of "command" may get modified while it is
|
||
executed. */
|
||
cleanups = make_cleanup (xfree, command);
|
||
|
||
std::string to_string_res;
|
||
|
||
TRY
|
||
{
|
||
scoped_restore restore_async = make_scoped_restore (¤t_ui->async,
|
||
0);
|
||
|
||
scoped_restore preventer = prevent_dont_repeat ();
|
||
if (to_string)
|
||
to_string_res = execute_command_to_string (command, from_tty);
|
||
else
|
||
execute_command (command, from_tty);
|
||
|
||
/* Do any commands attached to breakpoint we stopped at. */
|
||
bpstat_do_actions ();
|
||
}
|
||
CATCH (ex, RETURN_MASK_ALL)
|
||
{
|
||
except = ex;
|
||
}
|
||
END_CATCH
|
||
|
||
do_cleanups (cleanups);
|
||
GDBSCM_HANDLE_GDB_EXCEPTION (except);
|
||
|
||
if (to_string)
|
||
return gdbscm_scm_from_c_string (to_string_res.c_str ());
|
||
return SCM_UNSPECIFIED;
|
||
}
|
||
|
||
/* (data-directory) -> string */
|
||
|
||
static SCM
|
||
gdbscm_data_directory (void)
|
||
{
|
||
return gdbscm_scm_from_c_string (gdb_datadir);
|
||
}
|
||
|
||
/* (guile-data-directory) -> string */
|
||
|
||
static SCM
|
||
gdbscm_guile_data_directory (void)
|
||
{
|
||
return gdbscm_scm_from_c_string (guile_datadir);
|
||
}
|
||
|
||
/* (gdb-version) -> string */
|
||
|
||
static SCM
|
||
gdbscm_gdb_version (void)
|
||
{
|
||
return gdbscm_scm_from_c_string (version);
|
||
}
|
||
|
||
/* (host-config) -> string */
|
||
|
||
static SCM
|
||
gdbscm_host_config (void)
|
||
{
|
||
return gdbscm_scm_from_c_string (host_name);
|
||
}
|
||
|
||
/* (target-config) -> string */
|
||
|
||
static SCM
|
||
gdbscm_target_config (void)
|
||
{
|
||
return gdbscm_scm_from_c_string (target_name);
|
||
}
|
||
|
||
#else /* ! HAVE_GUILE */
|
||
|
||
/* Dummy implementation of the gdb "guile-repl" and "guile"
|
||
commands. */
|
||
|
||
static void
|
||
guile_repl_command (const char *arg, int from_tty)
|
||
{
|
||
arg = skip_spaces (arg);
|
||
if (arg && *arg)
|
||
error (_("guile-repl currently does not take any arguments."));
|
||
error (_("Guile scripting is not supported in this copy of GDB."));
|
||
}
|
||
|
||
static void
|
||
guile_command (const char *arg, int from_tty)
|
||
{
|
||
arg = skip_spaces (arg);
|
||
if (arg && *arg)
|
||
error (_("Guile scripting is not supported in this copy of GDB."));
|
||
else
|
||
{
|
||
/* Even if Guile isn't enabled, we still have to slurp the
|
||
command list to the corresponding "end". */
|
||
counted_command_line l = get_command_line (guile_control, "");
|
||
|
||
execute_control_command_untraced (l.get ());
|
||
}
|
||
}
|
||
|
||
#endif /* ! HAVE_GUILE */
|
||
|
||
/* Lists for 'set,show,info guile' commands. */
|
||
|
||
static struct cmd_list_element *set_guile_list;
|
||
static struct cmd_list_element *show_guile_list;
|
||
static struct cmd_list_element *info_guile_list;
|
||
|
||
/* Function for use by 'set guile' prefix command. */
|
||
|
||
static void
|
||
set_guile_command (const char *args, int from_tty)
|
||
{
|
||
help_list (set_guile_list, "set guile ", all_commands, gdb_stdout);
|
||
}
|
||
|
||
/* Function for use by 'show guile' prefix command. */
|
||
|
||
static void
|
||
show_guile_command (const char *args, int from_tty)
|
||
{
|
||
cmd_show_list (show_guile_list, from_tty, "");
|
||
}
|
||
|
||
/* The "info scheme" command is defined as a prefix, with
|
||
allow_unknown 0. Therefore, its own definition is called only for
|
||
"info scheme" with no args. */
|
||
|
||
static void
|
||
info_guile_command (const char *args, int from_tty)
|
||
{
|
||
printf_unfiltered (_("\"info guile\" must be followed"
|
||
" by the name of an info command.\n"));
|
||
help_list (info_guile_list, "info guile ", all_commands, gdb_stdout);
|
||
}
|
||
|
||
/* Initialization. */
|
||
|
||
#ifdef HAVE_GUILE
|
||
|
||
static const scheme_function misc_guile_functions[] =
|
||
{
|
||
{ "execute", 1, 0, 1, as_a_scm_t_subr (gdbscm_execute_gdb_command),
|
||
"\
|
||
Execute the given GDB command.\n\
|
||
\n\
|
||
Arguments: string [#:to-string boolean] [#:from-tty boolean]\n\
|
||
If #:from-tty is true then the command executes as if entered\n\
|
||
from the keyboard. The default is false (#f).\n\
|
||
If #:to-string is true then the result is returned as a string.\n\
|
||
Otherwise output is sent to the current output port,\n\
|
||
which is the default.\n\
|
||
Returns: The result of the command if #:to-string is true.\n\
|
||
Otherwise returns unspecified." },
|
||
|
||
{ "data-directory", 0, 0, 0, as_a_scm_t_subr (gdbscm_data_directory),
|
||
"\
|
||
Return the name of GDB's data directory." },
|
||
|
||
{ "guile-data-directory", 0, 0, 0,
|
||
as_a_scm_t_subr (gdbscm_guile_data_directory),
|
||
"\
|
||
Return the name of the Guile directory within GDB's data directory." },
|
||
|
||
{ "gdb-version", 0, 0, 0, as_a_scm_t_subr (gdbscm_gdb_version),
|
||
"\
|
||
Return GDB's version string." },
|
||
|
||
{ "host-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_host_config),
|
||
"\
|
||
Return the name of the host configuration." },
|
||
|
||
{ "target-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_target_config),
|
||
"\
|
||
Return the name of the target configuration." },
|
||
|
||
END_FUNCTIONS
|
||
};
|
||
|
||
/* Load BOOT_SCM_FILE, the first Scheme file that gets loaded. */
|
||
|
||
static SCM
|
||
boot_guile_support (void *boot_scm_file)
|
||
{
|
||
/* Load boot.scm without compiling it (there's no need to compile it).
|
||
The other files should have been compiled already, and boot.scm is
|
||
expected to adjust '%load-compiled-path' accordingly. If they haven't
|
||
been compiled, Guile will auto-compile them. The important thing to keep
|
||
in mind is that there's a >= 100x speed difference between compiled and
|
||
non-compiled files. */
|
||
return scm_c_primitive_load ((const char *) boot_scm_file);
|
||
}
|
||
|
||
/* Return non-zero if ARGS has the "standard" format for throw args.
|
||
The standard format is:
|
||
(function format-string (format-string-args-list) ...).
|
||
FUNCTION is #f if no function was recorded. */
|
||
|
||
static int
|
||
standard_throw_args_p (SCM args)
|
||
{
|
||
if (gdbscm_is_true (scm_list_p (args))
|
||
&& scm_ilength (args) >= 3)
|
||
{
|
||
/* The function in which the error occurred. */
|
||
SCM arg0 = scm_list_ref (args, scm_from_int (0));
|
||
/* The format string. */
|
||
SCM arg1 = scm_list_ref (args, scm_from_int (1));
|
||
/* The arguments of the format string. */
|
||
SCM arg2 = scm_list_ref (args, scm_from_int (2));
|
||
|
||
if ((scm_is_string (arg0) || gdbscm_is_false (arg0))
|
||
&& scm_is_string (arg1)
|
||
&& gdbscm_is_true (scm_list_p (arg2)))
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Print the error recorded in a "standard" throw args. */
|
||
|
||
static void
|
||
print_standard_throw_error (SCM args)
|
||
{
|
||
/* The function in which the error occurred. */
|
||
SCM arg0 = scm_list_ref (args, scm_from_int (0));
|
||
/* The format string. */
|
||
SCM arg1 = scm_list_ref (args, scm_from_int (1));
|
||
/* The arguments of the format string. */
|
||
SCM arg2 = scm_list_ref (args, scm_from_int (2));
|
||
|
||
/* ARG0 is #f if no function was recorded. */
|
||
if (gdbscm_is_true (arg0))
|
||
{
|
||
scm_simple_format (scm_current_error_port (),
|
||
scm_from_latin1_string (_("Error in function ~s:~%")),
|
||
scm_list_1 (arg0));
|
||
}
|
||
scm_simple_format (scm_current_error_port (), arg1, arg2);
|
||
}
|
||
|
||
/* Print the error message recorded in KEY, ARGS, the arguments to throw.
|
||
Normally we let Scheme print the error message.
|
||
This function is used when Scheme initialization fails.
|
||
We can still use the Scheme C API though. */
|
||
|
||
static void
|
||
print_throw_error (SCM key, SCM args)
|
||
{
|
||
/* IWBN to call gdbscm_print_exception_with_stack here, but Guile didn't
|
||
boot successfully so play it safe and avoid it. The "format string" and
|
||
its args are embedded in ARGS, but the content of ARGS depends on KEY.
|
||
Make sure ARGS has the expected canonical content before trying to use
|
||
it. */
|
||
if (standard_throw_args_p (args))
|
||
print_standard_throw_error (args);
|
||
else
|
||
{
|
||
scm_simple_format (scm_current_error_port (),
|
||
scm_from_latin1_string (_("Throw to key `~a' with args `~s'.~%")),
|
||
scm_list_2 (key, args));
|
||
}
|
||
}
|
||
|
||
/* Handle an exception thrown while loading BOOT_SCM_FILE. */
|
||
|
||
static SCM
|
||
handle_boot_error (void *boot_scm_file, SCM key, SCM args)
|
||
{
|
||
fprintf_unfiltered (gdb_stderr, ("Exception caught while booting Guile.\n"));
|
||
|
||
print_throw_error (key, args);
|
||
|
||
fprintf_unfiltered (gdb_stderr, "\n");
|
||
warning (_("Could not complete Guile gdb module initialization from:\n"
|
||
"%s.\n"
|
||
"Limited Guile support is available.\n"
|
||
"Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
|
||
(const char *) boot_scm_file);
|
||
|
||
return SCM_UNSPECIFIED;
|
||
}
|
||
|
||
/* Load gdb/boot.scm, the Scheme side of GDB/Guile support.
|
||
Note: This function assumes it's called within the gdb module. */
|
||
|
||
static void
|
||
initialize_scheme_side (void)
|
||
{
|
||
char *boot_scm_path;
|
||
|
||
guile_datadir = concat (gdb_datadir, SLASH_STRING, "guile", (char *) NULL);
|
||
boot_scm_path = concat (guile_datadir, SLASH_STRING, "gdb",
|
||
SLASH_STRING, boot_scm_filename, (char *) NULL);
|
||
|
||
scm_c_catch (SCM_BOOL_T, boot_guile_support, boot_scm_path,
|
||
handle_boot_error, boot_scm_path, NULL, NULL);
|
||
|
||
xfree (boot_scm_path);
|
||
}
|
||
|
||
/* Install the gdb scheme module.
|
||
The result is a boolean indicating success.
|
||
If initializing the gdb module fails an error message is printed.
|
||
Note: This function runs in the context of the gdb module. */
|
||
|
||
static void
|
||
initialize_gdb_module (void *data)
|
||
{
|
||
/* Computing these is a pain, so only do it once.
|
||
Also, do it here and save the result so that obtaining the values
|
||
is thread-safe. */
|
||
gdbscm_guile_major_version = gdbscm_scm_string_to_int (scm_major_version ());
|
||
gdbscm_guile_minor_version = gdbscm_scm_string_to_int (scm_minor_version ());
|
||
gdbscm_guile_micro_version = gdbscm_scm_string_to_int (scm_micro_version ());
|
||
|
||
/* The documentation symbol needs to be defined before any calls to
|
||
gdbscm_define_{variables,functions}. */
|
||
gdbscm_documentation_symbol = scm_from_latin1_symbol ("documentation");
|
||
|
||
/* The smob and exception support must be initialized early. */
|
||
gdbscm_initialize_smobs ();
|
||
gdbscm_initialize_exceptions ();
|
||
|
||
/* The rest are initialized in alphabetical order. */
|
||
gdbscm_initialize_arches ();
|
||
gdbscm_initialize_auto_load ();
|
||
gdbscm_initialize_blocks ();
|
||
gdbscm_initialize_breakpoints ();
|
||
gdbscm_initialize_commands ();
|
||
gdbscm_initialize_disasm ();
|
||
gdbscm_initialize_frames ();
|
||
gdbscm_initialize_iterators ();
|
||
gdbscm_initialize_lazy_strings ();
|
||
gdbscm_initialize_math ();
|
||
gdbscm_initialize_objfiles ();
|
||
gdbscm_initialize_parameters ();
|
||
gdbscm_initialize_ports ();
|
||
gdbscm_initialize_pretty_printers ();
|
||
gdbscm_initialize_pspaces ();
|
||
gdbscm_initialize_strings ();
|
||
gdbscm_initialize_symbols ();
|
||
gdbscm_initialize_symtabs ();
|
||
gdbscm_initialize_types ();
|
||
gdbscm_initialize_values ();
|
||
|
||
gdbscm_define_functions (misc_guile_functions, 1);
|
||
|
||
from_tty_keyword = scm_from_latin1_keyword ("from-tty");
|
||
to_string_keyword = scm_from_latin1_keyword ("to-string");
|
||
|
||
initialize_scheme_side ();
|
||
|
||
gdb_scheme_initialized = 1;
|
||
}
|
||
|
||
/* Utility to call scm_c_define_module+initialize_gdb_module from
|
||
within scm_with_guile. */
|
||
|
||
static void *
|
||
call_initialize_gdb_module (void *data)
|
||
{
|
||
/* Most of the initialization is done by initialize_gdb_module.
|
||
It is called via scm_c_define_module so that the initialization is
|
||
performed within the desired module. */
|
||
scm_c_define_module (gdbscm_module_name, initialize_gdb_module, NULL);
|
||
|
||
#if HAVE_GUILE_MANUAL_FINALIZATION
|
||
scm_run_finalizers ();
|
||
#endif
|
||
|
||
return NULL;
|
||
}
|
||
|
||
/* A callback to finish Guile initialization after gdb has finished all its
|
||
initialization.
|
||
This is the extension_language_ops.finish_initialization "method". */
|
||
|
||
static void
|
||
gdbscm_finish_initialization (const struct extension_language_defn *extlang)
|
||
{
|
||
/* Restore the environment to the user interaction one. */
|
||
scm_set_current_module (scm_interaction_environment ());
|
||
}
|
||
|
||
/* The extension_language_ops.initialized "method". */
|
||
|
||
static int
|
||
gdbscm_initialized (const struct extension_language_defn *extlang)
|
||
{
|
||
return gdb_scheme_initialized;
|
||
}
|
||
|
||
/* Enable or disable Guile backtraces. */
|
||
|
||
static void
|
||
gdbscm_set_backtrace (int enable)
|
||
{
|
||
static const char disable_bt[] = "(debug-disable 'backtrace)";
|
||
static const char enable_bt[] = "(debug-enable 'backtrace)";
|
||
|
||
if (enable)
|
||
gdbscm_safe_eval_string (enable_bt, 0);
|
||
else
|
||
gdbscm_safe_eval_string (disable_bt, 0);
|
||
}
|
||
|
||
#endif /* HAVE_GUILE */
|
||
|
||
/* Install the various gdb commands used by Guile. */
|
||
|
||
static void
|
||
install_gdb_commands (void)
|
||
{
|
||
add_com ("guile-repl", class_obscure,
|
||
guile_repl_command,
|
||
#ifdef HAVE_GUILE
|
||
_("\
|
||
Start an interactive Guile prompt.\n\
|
||
\n\
|
||
To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
|
||
prompt) or ,quit.")
|
||
#else /* HAVE_GUILE */
|
||
_("\
|
||
Start a Guile interactive prompt.\n\
|
||
\n\
|
||
Guile scripting is not supported in this copy of GDB.\n\
|
||
This command is only a placeholder.")
|
||
#endif /* HAVE_GUILE */
|
||
);
|
||
add_com_alias ("gr", "guile-repl", class_obscure, 1);
|
||
|
||
/* Since "help guile" is easy to type, and intuitive, we add general help
|
||
in using GDB+Guile to this command. */
|
||
add_com ("guile", class_obscure, guile_command,
|
||
#ifdef HAVE_GUILE
|
||
_("\
|
||
Evaluate one or more Guile expressions.\n\
|
||
\n\
|
||
The expression(s) can be given as an argument, for instance:\n\
|
||
\n\
|
||
guile (display 23)\n\
|
||
\n\
|
||
The result of evaluating the last expression is printed.\n\
|
||
\n\
|
||
If no argument is given, the following lines are read and passed\n\
|
||
to Guile for evaluation. Type a line containing \"end\" to indicate\n\
|
||
the end of the set of expressions.\n\
|
||
\n\
|
||
The Guile GDB module must first be imported before it can be used.\n\
|
||
Do this with:\n\
|
||
(gdb) guile (use-modules (gdb))\n\
|
||
or if you want to import the (gdb) module with a prefix, use:\n\
|
||
(gdb) guile (use-modules ((gdb) #:renamer (symbol-prefix-proc 'gdb:)))\n\
|
||
\n\
|
||
The Guile interactive session, started with the \"guile-repl\"\n\
|
||
command, provides extensive help and apropos capabilities.\n\
|
||
Type \",help\" once in a Guile interactive session.")
|
||
#else /* HAVE_GUILE */
|
||
_("\
|
||
Evaluate a Guile expression.\n\
|
||
\n\
|
||
Guile scripting is not supported in this copy of GDB.\n\
|
||
This command is only a placeholder.")
|
||
#endif /* HAVE_GUILE */
|
||
);
|
||
add_com_alias ("gu", "guile", class_obscure, 1);
|
||
|
||
add_prefix_cmd ("guile", class_obscure, set_guile_command,
|
||
_("Prefix command for Guile preference settings."),
|
||
&set_guile_list, "set guile ", 0,
|
||
&setlist);
|
||
add_alias_cmd ("gu", "guile", class_obscure, 1, &setlist);
|
||
|
||
add_prefix_cmd ("guile", class_obscure, show_guile_command,
|
||
_("Prefix command for Guile preference settings."),
|
||
&show_guile_list, "show guile ", 0,
|
||
&showlist);
|
||
add_alias_cmd ("gu", "guile", class_obscure, 1, &showlist);
|
||
|
||
add_prefix_cmd ("guile", class_obscure, info_guile_command,
|
||
_("Prefix command for Guile info displays."),
|
||
&info_guile_list, "info guile ", 0,
|
||
&infolist);
|
||
add_info_alias ("gu", "guile", 1);
|
||
|
||
/* The name "print-stack" is carried over from Python.
|
||
A better name is "print-exception". */
|
||
add_setshow_enum_cmd ("print-stack", no_class, guile_print_excp_enums,
|
||
&gdbscm_print_excp, _("\
|
||
Set mode for Guile exception printing on error."), _("\
|
||
Show the mode of Guile exception printing on error."), _("\
|
||
none == no stack or message will be printed.\n\
|
||
full == a message and a stack will be printed.\n\
|
||
message == an error message without a stack will be printed."),
|
||
NULL, NULL,
|
||
&set_guile_list, &show_guile_list);
|
||
}
|
||
|
||
void
|
||
_initialize_guile (void)
|
||
{
|
||
install_gdb_commands ();
|
||
|
||
#if HAVE_GUILE
|
||
{
|
||
#ifdef HAVE_SIGPROCMASK
|
||
sigset_t sigchld_mask, prev_mask;
|
||
#endif
|
||
|
||
/* The Python support puts the C side in module "_gdb", leaving the Python
|
||
side to define module "gdb" which imports "_gdb". There is evidently no
|
||
similar convention in Guile so we skip this. */
|
||
|
||
#if HAVE_GUILE_MANUAL_FINALIZATION
|
||
/* Our SMOB free functions are not thread-safe, as GDB itself is not
|
||
intended to be thread-safe. Disable automatic finalization so that
|
||
finalizers aren't run in other threads. */
|
||
scm_set_automatic_finalization_enabled (0);
|
||
#endif
|
||
|
||
#ifdef HAVE_SIGPROCMASK
|
||
/* Before we initialize Guile, block SIGCHLD.
|
||
This is done so that all threads created during Guile initialization
|
||
have SIGCHLD blocked. PR 17247.
|
||
Really libgc and Guile should do this, but we need to work with
|
||
libgc 7.4.x. */
|
||
sigemptyset (&sigchld_mask);
|
||
sigaddset (&sigchld_mask, SIGCHLD);
|
||
sigprocmask (SIG_BLOCK, &sigchld_mask, &prev_mask);
|
||
#endif
|
||
|
||
/* scm_with_guile is the most portable way to initialize Guile.
|
||
Plus we need to initialize the Guile support while in Guile mode
|
||
(e.g., called from within a call to scm_with_guile). */
|
||
scm_with_guile (call_initialize_gdb_module, NULL);
|
||
|
||
#ifdef HAVE_SIGPROCMASK
|
||
sigprocmask (SIG_SETMASK, &prev_mask, NULL);
|
||
#endif
|
||
|
||
/* Set Guile's backtrace to match the "set guile print-stack" default.
|
||
[N.B. The two settings are still separate.]
|
||
But only do this after we've initialized Guile, it's nice to see a
|
||
backtrace if there's an error during initialization.
|
||
OTOH, if the error is that gdb/init.scm wasn't found because gdb is
|
||
being run from the build tree, the backtrace is more noise than signal.
|
||
Sigh. */
|
||
gdbscm_set_backtrace (0);
|
||
}
|
||
#endif
|
||
}
|