/* Scheme interface to breakpoints.
Copyright (C) 2008-2020 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 "value.h"
#include "breakpoint.h"
#include "gdbcmd.h"
#include "gdbthread.h"
#include "observable.h"
#include "cli/cli-script.h"
#include "ada-lang.h"
#include "arch-utils.h"
#include "language.h"
#include "guile-internal.h"
#include "location.h"
/* The <gdb:breakpoint> smob.
N.B.: The name of this struct is known to breakpoint.h.
Note: Breakpoints are added to gdb using a two step process:
1) Call make-breakpoint to create a <gdb:breakpoint> object.
2) Call register-breakpoint! to add the breakpoint to gdb.
It is done this way so that the constructor, make-breakpoint, doesn't have
any side-effects. This means that the smob needs to store everything
that was passed to make-breakpoint. */
typedef struct gdbscm_breakpoint_object
{
/* This always appears first. */
gdb_smob base;
/* Non-zero if this breakpoint was created with make-breakpoint. */
int is_scheme_bkpt;
/* For breakpoints created with make-breakpoint, these are the parameters
that were passed to make-breakpoint. These values are not used except
to register the breakpoint with GDB. */
struct
{
/* The string representation of the breakpoint.
Space for this lives in GC space. */
char *location;
/* The kind of breakpoint.
At the moment this can only be one of bp_breakpoint, bp_watchpoint. */
enum bptype type;
/* If a watchpoint, the kind of watchpoint. */
enum target_hw_bp_type access_type;
/* Non-zero if the breakpoint is an "internal" breakpoint. */
int is_internal;
} spec;
/* The breakpoint number according to gdb.
For breakpoints created from Scheme, this has the value -1 until the
breakpoint is registered with gdb.
This is recorded here because BP will be NULL when deleted. */
int number;
/* The gdb breakpoint object, or NULL if the breakpoint has not been
registered yet, or has been deleted. */
struct breakpoint *bp;
/* Backlink to our containing <gdb:breakpoint> smob.
This is needed when we are deleted, we need to unprotect the object
from GC. */
SCM containing_scm;
/* A stop condition or #f. */
SCM stop;
} breakpoint_smob;
static const char breakpoint_smob_name[] = "gdb:breakpoint";
/* The tag Guile knows the breakpoint smob by. */
static scm_t_bits breakpoint_smob_tag;
/* Variables used to pass information between the breakpoint_smob
constructor and the breakpoint-created hook function. */
static SCM pending_breakpoint_scm = SCM_BOOL_F;
/* Keywords used by create-breakpoint!. */
static SCM type_keyword;
static SCM wp_class_keyword;
static SCM internal_keyword;
/* Administrivia for breakpoint smobs. */
/* The smob "free" function for <gdb:breakpoint>. */
static size_t
bpscm_free_breakpoint_smob (SCM self)
{
breakpoint_smob *bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (self);
if (bp_smob->bp)
bp_smob->bp->scm_bp_object = NULL;
/* Not necessary, done to catch bugs. */
bp_smob->bp = NULL;
bp_smob->containing_scm = SCM_UNDEFINED;
bp_smob->stop = SCM_UNDEFINED;
return 0;
}
/* Return the name of TYPE.
This doesn't handle all types, just the ones we export. */
static const char *
bpscm_type_to_string (enum bptype type)
{
switch (type)
{
case bp_none: return "BP_NONE";
case bp_breakpoint: return "BP_BREAKPOINT";
case bp_watchpoint: return "BP_WATCHPOINT";
case bp_hardware_watchpoint: return "BP_HARDWARE_WATCHPOINT";
case bp_read_watchpoint: return "BP_READ_WATCHPOINT";
case bp_access_watchpoint: return "BP_ACCESS_WATCHPOINT";
default: return "internal/other";
}
}
/* Return the name of ENABLE_STATE. */
static const char *
bpscm_enable_state_to_string (enum enable_state enable_state)
{
switch (enable_state)
{
case bp_disabled: return "disabled";
case bp_enabled: return "enabled";
case bp_call_disabled: return "call_disabled";
default: return "unknown";
}
}
/* The smob "print" function for <gdb:breakpoint>. */
static int
bpscm_print_breakpoint_smob (SCM self, SCM port, scm_print_state *pstate)
{
breakpoint_smob *bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (self);
struct breakpoint *b = bp_smob->bp;
gdbscm_printf (port, "#<%s", breakpoint_smob_name);
/* Only print what we export to the user.
The rest are possibly internal implementation details. */
gdbscm_printf (port, " #%d", bp_smob->number);
/* Careful, the breakpoint may be invalid. */
if (b != NULL)
{
const char *str;
gdbscm_printf (port, " %s %s %s",
bpscm_type_to_string (b->type),
bpscm_enable_state_to_string (b->enable_state),
b->silent ? "silent" : "noisy");
gdbscm_printf (port, " hit:%d", b->hit_count);
gdbscm_printf (port, " ignore:%d", b->ignore_count);
str = event_location_to_string (b->location.get ());
if (str != NULL)
gdbscm_printf (port, " @%s", str);
}
scm_puts (">", port);
scm_remember_upto_here_1 (self);
/* Non-zero means success. */
return 1;
}
/* Low level routine to create a <gdb:breakpoint> object. */
static SCM
bpscm_make_breakpoint_smob (void)
{
breakpoint_smob *bp_smob = (breakpoint_smob *)
scm_gc_malloc (sizeof (breakpoint_smob), breakpoint_smob_name);
SCM bp_scm;
memset (bp_smob, 0, sizeof (*bp_smob));
bp_smob->number = -1;
bp_smob->stop = SCM_BOOL_F;
bp_scm = scm_new_smob (breakpoint_smob_tag, (scm_t_bits) bp_smob);
bp_smob->containing_scm = bp_scm;
gdbscm_init_gsmob (&bp_smob->base);
return bp_scm;
}
/* Return non-zero if we want a Scheme wrapper for breakpoint B.
If FROM_SCHEME is non-zero,this is called for a breakpoint created
by the user from Scheme. Otherwise it is zero. */
static int
bpscm_want_scm_wrapper_p (struct breakpoint *bp, int from_scheme)
{
/* Don't create <gdb:breakpoint> objects for internal GDB breakpoints. */
if (bp->number < 0 && !from_scheme)
return 0;
/* The others are not supported. */
if (bp->type != bp_breakpoint
&& bp->type != bp_watchpoint
&& bp->type != bp_hardware_watchpoint
&& bp->type != bp_read_watchpoint
&& bp->type != bp_access_watchpoint)
return 0;
return 1;
}
/* Install the Scheme side of a breakpoint, CONTAINING_SCM, in
the gdb side BP. */
static void
bpscm_attach_scm_to_breakpoint (struct breakpoint *bp, SCM containing_scm)
{
breakpoint_smob *bp_smob;
bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (containing_scm);
bp_smob->number = bp->number;
bp_smob->bp = bp;
bp_smob->containing_scm = containing_scm;
bp_smob->bp->scm_bp_object = bp_smob;
/* The owner of this breakpoint is not in GC-controlled memory, so we need
to protect it from GC until the breakpoint is deleted. */
scm_gc_protect_object (containing_scm);
}
/* Return non-zero if SCM is a breakpoint smob. */
static int
bpscm_is_breakpoint (SCM scm)
{
return SCM_SMOB_PREDICATE (breakpoint_smob_tag, scm);
}
/* (breakpoint? scm) -> boolean */
static SCM
gdbscm_breakpoint_p (SCM scm)
{
return scm_from_bool (bpscm_is_breakpoint (scm));
}
/* Returns the <gdb:breakpoint> object in SELF.
Throws an exception if SELF is not a <gdb:breakpoint> object. */
static SCM
bpscm_get_breakpoint_arg_unsafe (SCM self, int arg_pos, const char *func_name)
{
SCM_ASSERT_TYPE (bpscm_is_breakpoint (self), self, arg_pos, func_name,
breakpoint_smob_name);
return self;
}
/* Returns a pointer to the breakpoint smob of SELF.
Throws an exception if SELF is not a <gdb:breakpoint> object. */
static breakpoint_smob *
bpscm_get_breakpoint_smob_arg_unsafe (SCM self, int arg_pos,
const char *func_name)
{
SCM bp_scm = bpscm_get_breakpoint_arg_unsafe (self, arg_pos, func_name);
breakpoint_smob *bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (bp_scm);
return bp_smob;
}
/* Return non-zero if breakpoint BP_SMOB is valid. */
static int
bpscm_is_valid (breakpoint_smob *bp_smob)
{
return bp_smob->bp != NULL;
}
/* Returns the breakpoint smob in SELF, verifying it's valid.
Throws an exception if SELF is not a <gdb:breakpoint> object,
or is invalid. */
static breakpoint_smob *
bpscm_get_valid_breakpoint_smob_arg_unsafe (SCM self, int arg_pos,
const char *func_name)
{
breakpoint_smob *bp_smob
= bpscm_get_breakpoint_smob_arg_unsafe (self, arg_pos, func_name);
if (!bpscm_is_valid (bp_smob))
{
gdbscm_invalid_object_error (func_name, arg_pos, self,
_("<gdb:breakpoint>"));
}
return bp_smob;
}
/* Breakpoint methods. */
/* (make-breakpoint string [#:type integer] [#:wp-class integer]
[#:internal boolean) -> <gdb:breakpoint>
The result is the <gdb:breakpoint> Scheme object.
The breakpoint is not available to be used yet, however.
It must still be added to gdb with register-breakpoint!. */
static SCM
gdbscm_make_breakpoint (SCM location_scm, SCM rest)
{
const SCM keywords[] = {
type_keyword, wp_class_keyword, internal_keyword, SCM_BOOL_F
};
char *s;
char *location;
int type_arg_pos = -1, access_type_arg_pos = -1, internal_arg_pos = -1;
enum bptype type = bp_breakpoint;
enum target_hw_bp_type access_type = hw_write;
int internal = 0;
SCM result;
breakpoint_smob *bp_smob;
gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, keywords, "s#iit",
location_scm, &location, rest,
&type_arg_pos, &type,
&access_type_arg_pos, &access_type,
&internal_arg_pos, &internal);
result = bpscm_make_breakpoint_smob ();
bp_smob = (breakpoint_smob *) SCM_SMOB_DATA (result);
s = location;
location = gdbscm_gc_xstrdup (s);
xfree (s);
switch (type)
{
case bp_breakpoint:
if (access_type_arg_pos > 0)
{
gdbscm_misc_error (FUNC_NAME, access_type_arg_pos,
scm_from_int (access_type),
_("access type with breakpoint is not allowed"));
}
break;
case bp_watchpoint:
switch (access_type)
{
case hw_write:
case hw_access:
case hw_read:
break;
default:
gdbscm_out_of_range_error (FUNC_NAME, access_type_arg_pos,
scm_from_int (access_type),
_("invalid watchpoint class"));
}
break;
default:
gdbscm_out_of_range_error (FUNC_NAME, access_type_arg_pos,
scm_from_int (type),
_("invalid breakpoint type"));
}
bp_smob->is_scheme_bkpt = 1;
bp_smob->spec.location = location;
bp_smob->spec.type = type;
bp_smob->spec.access_type = access_type;
bp_smob->spec.is_internal = internal;
return result;
}
/* (register-breakpoint! <gdb:breakpoint>) -> unspecified
It is an error to register a breakpoint created outside of Guile,
or an already-registered breakpoint. */
static SCM
gdbscm_register_breakpoint_x (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
gdbscm_gdb_exception except {};
const char *location, *copy;
/* We only support registering breakpoints created with make-breakpoint. */
if (!bp_smob->is_scheme_bkpt)
scm_misc_error (FUNC_NAME, _("not a Scheme breakpoint"), SCM_EOL);
if (bpscm_is_valid (bp_smob))
scm_misc_error (FUNC_NAME, _("breakpoint is already registered"), SCM_EOL);
pending_breakpoint_scm = self;
location = bp_smob->spec.location;
copy = skip_spaces (location);
event_location_up eloc
= string_to_event_location_basic (©,
current_language,
symbol_name_match_type::WILD);
try
{
int internal = bp_smob->spec.is_internal;
switch (bp_smob->spec.type)
{
case bp_breakpoint:
{
const breakpoint_ops *ops =
breakpoint_ops_for_event_location (eloc.get (), false);
create_breakpoint (get_current_arch (),
eloc.get (), NULL, -1, NULL,
0,
0, bp_breakpoint,
0,
AUTO_BOOLEAN_TRUE,
ops,
0, 1, internal, 0);
break;
}
case bp_watchpoint:
{
enum target_hw_bp_type access_type = bp_smob->spec.access_type;
if (access_type == hw_write)
watch_command_wrapper (location, 0, internal);
else if (access_type == hw_access)
awatch_command_wrapper (location, 0, internal);
else if (access_type == hw_read)
rwatch_command_wrapper (location, 0, internal);
else
gdb_assert_not_reached ("invalid access type");
break;
}
default:
gdb_assert_not_reached ("invalid breakpoint type");
}
}
catch (const gdb_exception &ex)
{
except = unpack (ex);
}
/* Ensure this gets reset, even if there's an error. */
pending_breakpoint_scm = SCM_BOOL_F;
GDBSCM_HANDLE_GDB_EXCEPTION (except);
return SCM_UNSPECIFIED;
}
/* (delete-breakpoint! <gdb:breakpoint>) -> unspecified
Scheme function which deletes (removes) the underlying GDB breakpoint
from GDB's list of breakpoints. This triggers the breakpoint_deleted
observer which will call gdbscm_breakpoint_deleted; that function cleans
up the Scheme bits. */
static SCM
gdbscm_delete_breakpoint_x (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
gdbscm_gdb_exception exc {};
try
{
delete_breakpoint (bp_smob->bp);
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
return SCM_UNSPECIFIED;
}
/* iterate_over_breakpoints function for gdbscm_breakpoints. */
static bool
bpscm_build_bp_list (struct breakpoint *bp, SCM *list)
{
breakpoint_smob *bp_smob = bp->scm_bp_object;
/* Lazily create wrappers for breakpoints created outside Scheme. */
if (bp_smob == NULL)
{
if (bpscm_want_scm_wrapper_p (bp, 0))
{
SCM bp_scm;
bp_scm = bpscm_make_breakpoint_smob ();
bpscm_attach_scm_to_breakpoint (bp, bp_scm);
/* Refetch it. */
bp_smob = bp->scm_bp_object;
}
}
/* Not all breakpoints will have a companion Scheme object.
Only breakpoints that trigger the created_breakpoint observer call,
and satisfy certain conditions (see bpscm_want_scm_wrapper_p),
get a companion object (this includes Scheme-created breakpoints). */
if (bp_smob != NULL)
*list = scm_cons (bp_smob->containing_scm, *list);
return false;
}
/* (breakpoints) -> list
Return a list of all breakpoints. */
static SCM
gdbscm_breakpoints (void)
{
SCM list = SCM_EOL;
iterate_over_breakpoints ([&] (breakpoint *bp)
{
return bpscm_build_bp_list(bp, &list);
});
return scm_reverse_x (list, SCM_EOL);
}
/* (breakpoint-valid? <gdb:breakpoint>) -> boolean
Returns #t if SELF is still valid. */
static SCM
gdbscm_breakpoint_valid_p (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_bool (bpscm_is_valid (bp_smob));
}
/* (breakpoint-enabled? <gdb:breakpoint>) -> boolean */
static SCM
gdbscm_breakpoint_enabled_p (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_bool (bp_smob->bp->enable_state == bp_enabled);
}
/* (set-breakpoint-enabled? <gdb:breakpoint> boolean) -> unspecified */
static SCM
gdbscm_set_breakpoint_enabled_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
SCM_ASSERT_TYPE (gdbscm_is_bool (newvalue), newvalue, SCM_ARG2, FUNC_NAME,
_("boolean"));
gdbscm_gdb_exception exc {};
try
{
if (gdbscm_is_true (newvalue))
enable_breakpoint (bp_smob->bp);
else
disable_breakpoint (bp_smob->bp);
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
return SCM_UNSPECIFIED;
}
/* (breakpoint-silent? <gdb:breakpoint>) -> boolean */
static SCM
gdbscm_breakpoint_silent_p (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_bool (bp_smob->bp->silent);
}
/* (set-breakpoint-silent?! <gdb:breakpoint> boolean) -> unspecified */
static SCM
gdbscm_set_breakpoint_silent_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
SCM_ASSERT_TYPE (gdbscm_is_bool (newvalue), newvalue, SCM_ARG2, FUNC_NAME,
_("boolean"));
gdbscm_gdb_exception exc {};
try
{
breakpoint_set_silent (bp_smob->bp, gdbscm_is_true (newvalue));
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
return SCM_UNSPECIFIED;
}
/* (breakpoint-ignore-count <gdb:breakpoint>) -> integer */
static SCM
gdbscm_breakpoint_ignore_count (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_long (bp_smob->bp->ignore_count);
}
/* (set-breakpoint-ignore-count! <gdb:breakpoint> integer)
-> unspecified */
static SCM
gdbscm_set_breakpoint_ignore_count_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
long value;
SCM_ASSERT_TYPE (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX),
newvalue, SCM_ARG2, FUNC_NAME, _("integer"));
value = scm_to_long (newvalue);
if (value < 0)
value = 0;
gdbscm_gdb_exception exc {};
try
{
set_ignore_count (bp_smob->number, (int) value, 0);
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
return SCM_UNSPECIFIED;
}
/* (breakpoint-hit-count <gdb:breakpoint>) -> integer */
static SCM
gdbscm_breakpoint_hit_count (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_long (bp_smob->bp->hit_count);
}
/* (set-breakpoint-hit-count! <gdb:breakpoint> integer) -> unspecified */
static SCM
gdbscm_set_breakpoint_hit_count_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
long value;
SCM_ASSERT_TYPE (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX),
newvalue, SCM_ARG2, FUNC_NAME, _("integer"));
value = scm_to_long (newvalue);
if (value < 0)
value = 0;
if (value != 0)
{
gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, newvalue,
_("hit-count must be zero"));
}
bp_smob->bp->hit_count = 0;
return SCM_UNSPECIFIED;
}
/* (breakpoint-thread <gdb:breakpoint>) -> integer */
static SCM
gdbscm_breakpoint_thread (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
if (bp_smob->bp->thread == -1)
return SCM_BOOL_F;
return scm_from_long (bp_smob->bp->thread);
}
/* (set-breakpoint-thread! <gdb:breakpoint> integer) -> unspecified */
static SCM
gdbscm_set_breakpoint_thread_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
long id;
if (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX))
{
id = scm_to_long (newvalue);
if (!valid_global_thread_id (id))
{
gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, newvalue,
_("invalid thread id"));
}
}
else if (gdbscm_is_false (newvalue))
id = -1;
else
SCM_ASSERT_TYPE (0, newvalue, SCM_ARG2, FUNC_NAME, _("integer or #f"));
breakpoint_set_thread (bp_smob->bp, id);
return SCM_UNSPECIFIED;
}
/* (breakpoint-task <gdb:breakpoint>) -> integer */
static SCM
gdbscm_breakpoint_task (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
if (bp_smob->bp->task == 0)
return SCM_BOOL_F;
return scm_from_long (bp_smob->bp->task);
}
/* (set-breakpoint-task! <gdb:breakpoint> integer) -> unspecified */
static SCM
gdbscm_set_breakpoint_task_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
long id;
int valid_id = 0;
if (scm_is_signed_integer (newvalue, LONG_MIN, LONG_MAX))
{
id = scm_to_long (newvalue);
gdbscm_gdb_exception exc {};
try
{
valid_id = valid_task_id (id);
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
if (! valid_id)
{
gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG2, newvalue,
_("invalid task id"));
}
}
else if (gdbscm_is_false (newvalue))
id = 0;
else
SCM_ASSERT_TYPE (0, newvalue, SCM_ARG2, FUNC_NAME, _("integer or #f"));
gdbscm_gdb_exception exc {};
try
{
breakpoint_set_task (bp_smob->bp, id);
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
return SCM_UNSPECIFIED;
}
/* (breakpoint-location <gdb:breakpoint>) -> string */
static SCM
gdbscm_breakpoint_location (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
const char *str;
if (bp_smob->bp->type != bp_breakpoint)
return SCM_BOOL_F;
str = event_location_to_string (bp_smob->bp->location.get ());
if (! str)
str = "";
return gdbscm_scm_from_c_string (str);
}
/* (breakpoint-expression <gdb:breakpoint>) -> string
This is only valid for watchpoints.
Returns #f for non-watchpoints. */
static SCM
gdbscm_breakpoint_expression (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
struct watchpoint *wp;
if (!is_watchpoint (bp_smob->bp))
return SCM_BOOL_F;
wp = (struct watchpoint *) bp_smob->bp;
const char *str = wp->exp_string;
if (! str)
str = "";
return gdbscm_scm_from_c_string (str);
}
/* (breakpoint-condition <gdb:breakpoint>) -> string */
static SCM
gdbscm_breakpoint_condition (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
char *str;
str = bp_smob->bp->cond_string;
if (! str)
return SCM_BOOL_F;
return gdbscm_scm_from_c_string (str);
}
/* (set-breakpoint-condition! <gdb:breakpoint> string|#f)
-> unspecified */
static SCM
gdbscm_set_breakpoint_condition_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
SCM_ASSERT_TYPE (scm_is_string (newvalue) || gdbscm_is_false (newvalue),
newvalue, SCM_ARG2, FUNC_NAME,
_("string or #f"));
return gdbscm_wrap ([=]
{
gdb::unique_xmalloc_ptr<char> exp
= (gdbscm_is_false (newvalue)
? nullptr
: gdbscm_scm_to_c_string (newvalue));
set_breakpoint_condition (bp_smob->bp, exp ? exp.get () : "", 0);
return SCM_UNSPECIFIED;
});
}
/* (breakpoint-stop <gdb:breakpoint>) -> procedure or #f */
static SCM
gdbscm_breakpoint_stop (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return bp_smob->stop;
}
/* (set-breakpoint-stop! <gdb:breakpoint> procedure|#f)
-> unspecified */
static SCM
gdbscm_set_breakpoint_stop_x (SCM self, SCM newvalue)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
const struct extension_language_defn *extlang = NULL;
SCM_ASSERT_TYPE (gdbscm_is_procedure (newvalue)
|| gdbscm_is_false (newvalue),
newvalue, SCM_ARG2, FUNC_NAME,
_("procedure or #f"));
if (bp_smob->bp->cond_string != NULL)
extlang = get_ext_lang_defn (EXT_LANG_GDB);
if (extlang == NULL)
extlang = get_breakpoint_cond_ext_lang (bp_smob->bp, EXT_LANG_GUILE);
if (extlang != NULL)
{
char *error_text
= xstrprintf (_("Only one stop condition allowed. There is"
" currently a %s stop condition defined for"
" this breakpoint."),
ext_lang_capitalized_name (extlang));
scm_dynwind_begin ((scm_t_dynwind_flags) 0);
gdbscm_dynwind_xfree (error_text);
gdbscm_out_of_range_error (FUNC_NAME, SCM_ARG1, self, error_text);
/* The following line, while unnecessary, is present for completeness
sake. */
scm_dynwind_end ();
}
bp_smob->stop = newvalue;
return SCM_UNSPECIFIED;
}
/* (breakpoint-commands <gdb:breakpoint>) -> string */
static SCM
gdbscm_breakpoint_commands (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
struct breakpoint *bp;
SCM result;
bp = bp_smob->bp;
if (bp->commands == NULL)
return SCM_BOOL_F;
string_file buf;
current_uiout->redirect (&buf);
gdbscm_gdb_exception exc {};
try
{
print_command_lines (current_uiout, breakpoint_commands (bp), 0);
}
catch (const gdb_exception &except)
{
exc = unpack (except);
}
current_uiout->redirect (NULL);
GDBSCM_HANDLE_GDB_EXCEPTION (exc);
result = gdbscm_scm_from_c_string (buf.c_str ());
return result;
}
/* (breakpoint-type <gdb:breakpoint>) -> integer */
static SCM
gdbscm_breakpoint_type (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_long (bp_smob->bp->type);
}
/* (breakpoint-visible? <gdb:breakpoint>) -> boolean */
static SCM
gdbscm_breakpoint_visible (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_bool (bp_smob->bp->number >= 0);
}
/* (breakpoint-number <gdb:breakpoint>) -> integer */
static SCM
gdbscm_breakpoint_number (SCM self)
{
breakpoint_smob *bp_smob
= bpscm_get_valid_breakpoint_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
return scm_from_long (bp_smob->number);
}
/* Return TRUE if "stop" has been set for this breakpoint.
This is the extension_language_ops.breakpoint_has_cond "method". */
int
gdbscm_breakpoint_has_cond (const struct extension_language_defn *extlang,
struct breakpoint *b)
{
breakpoint_smob *bp_smob = b->scm_bp_object;
if (bp_smob == NULL)
return 0;
return gdbscm_is_procedure (bp_smob->stop);
}
/* Call the "stop" method in the breakpoint class.
This must only be called if gdbscm_breakpoint_has_cond returns true.
If the stop method returns #t, the inferior will be stopped at the
breakpoint. Otherwise the inferior will be allowed to continue
(assuming other conditions don't indicate "stop").
This is the extension_language_ops.breakpoint_cond_says_stop "method". */
enum ext_lang_bp_stop
gdbscm_breakpoint_cond_says_stop
(const struct extension_language_defn *extlang, struct breakpoint *b)
{
breakpoint_smob *bp_smob = b->scm_bp_object;
SCM predicate_result;
int stop;
if (bp_smob == NULL)
return EXT_LANG_BP_STOP_UNSET;
if (!gdbscm_is_procedure (bp_smob->stop))
return EXT_LANG_BP_STOP_UNSET;
stop = 1;
predicate_result
= gdbscm_safe_call_1 (bp_smob->stop, bp_smob->containing_scm, NULL);
if (gdbscm_is_exception (predicate_result))
; /* Exception already printed. */
/* If the "stop" function returns #f that means
the Scheme breakpoint wants GDB to continue. */
else if (gdbscm_is_false (predicate_result))
stop = 0;
return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
}
/* Event callback functions. */
/* Callback that is used when a breakpoint is created.
For breakpoints created by Scheme, i.e., gdbscm_create_breakpoint_x, finish
object creation by connecting the Scheme wrapper to the gdb object.
We ignore breakpoints created from gdb or python here, we create the
Scheme wrapper for those when there's a need to, e.g.,
gdbscm_breakpoints. */
static void
bpscm_breakpoint_created (struct breakpoint *bp)
{
SCM bp_scm;
if (gdbscm_is_false (pending_breakpoint_scm))
return;
/* Verify our caller error checked the user's request. */
gdb_assert (bpscm_want_scm_wrapper_p (bp, 1));
bp_scm = pending_breakpoint_scm;
pending_breakpoint_scm = SCM_BOOL_F;
bpscm_attach_scm_to_breakpoint (bp, bp_scm);
}
/* Callback that is used when a breakpoint is deleted. This will
invalidate the corresponding Scheme object. */
static void
bpscm_breakpoint_deleted (struct breakpoint *b)
{
int num = b->number;
struct breakpoint *bp;
/* TODO: Why the lookup? We have B. */
bp = get_breakpoint (num);
if (bp)
{
breakpoint_smob *bp_smob = bp->scm_bp_object;
if (bp_smob)
{
bp_smob->bp = NULL;
bp_smob->number = -1;
bp_smob->stop = SCM_BOOL_F;
scm_gc_unprotect_object (bp_smob->containing_scm);
}
}
}
/* Initialize the Scheme breakpoint code. */
static const scheme_integer_constant breakpoint_integer_constants[] =
{
{ "BP_NONE", bp_none },
{ "BP_BREAKPOINT", bp_breakpoint },
{ "BP_WATCHPOINT", bp_watchpoint },
{ "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint },
{ "BP_READ_WATCHPOINT", bp_read_watchpoint },
{ "BP_ACCESS_WATCHPOINT", bp_access_watchpoint },
{ "WP_READ", hw_read },
{ "WP_WRITE", hw_write },
{ "WP_ACCESS", hw_access },
END_INTEGER_CONSTANTS
};
static const scheme_function breakpoint_functions[] =
{
{ "make-breakpoint", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_breakpoint),
"\
Create a GDB breakpoint object.\n\
\n\
Arguments:\n\
location [#:type <type>] [#:wp-class <wp-class>] [#:internal <bool>]\n\
Returns:\n\
<gdb:breakpoint object" },
{ "register-breakpoint!", 1, 0, 0,
as_a_scm_t_subr (gdbscm_register_breakpoint_x),
"\
Register a <gdb:breakpoint> object with GDB." },
{ "delete-breakpoint!", 1, 0, 0, as_a_scm_t_subr (gdbscm_delete_breakpoint_x),
"\
Delete the breakpoint from GDB." },
{ "breakpoints", 0, 0, 0, as_a_scm_t_subr (gdbscm_breakpoints),
"\
Return a list of all GDB breakpoints.\n\
\n\
Arguments: none" },
{ "breakpoint?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_p),
"\
Return #t if the object is a <gdb:breakpoint> object." },
{ "breakpoint-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_valid_p),
"\
Return #t if the breakpoint has not been deleted from GDB." },
{ "breakpoint-number", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_number),
"\
Return the breakpoint's number." },
{ "breakpoint-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_type),
"\
Return the type of the breakpoint." },
{ "breakpoint-visible?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_visible),
"\
Return #t if the breakpoint is visible to the user." },
{ "breakpoint-location", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_location),
"\
Return the location of the breakpoint as specified by the user." },
{ "breakpoint-expression", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_expression),
"\
Return the expression of the breakpoint as specified by the user.\n\
Valid for watchpoints only, returns #f for non-watchpoints." },
{ "breakpoint-enabled?", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_enabled_p),
"\
Return #t if the breakpoint is enabled." },
{ "set-breakpoint-enabled!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_enabled_x),
"\
Set the breakpoint's enabled state.\n\
\n\
Arguments: <gdb:breakpoint> boolean" },
{ "breakpoint-silent?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_silent_p),
"\
Return #t if the breakpoint is silent." },
{ "set-breakpoint-silent!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_silent_x),
"\
Set the breakpoint's silent state.\n\
\n\
Arguments: <gdb:breakpoint> boolean" },
{ "breakpoint-ignore-count", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_ignore_count),
"\
Return the breakpoint's \"ignore\" count." },
{ "set-breakpoint-ignore-count!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_ignore_count_x),
"\
Set the breakpoint's \"ignore\" count.\n\
\n\
Arguments: <gdb:breakpoint> count" },
{ "breakpoint-hit-count", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_hit_count),
"\
Return the breakpoint's \"hit\" count." },
{ "set-breakpoint-hit-count!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_hit_count_x),
"\
Set the breakpoint's \"hit\" count. The value must be zero.\n\
\n\
Arguments: <gdb:breakpoint> 0" },
{ "breakpoint-thread", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_thread),
"\
Return the breakpoint's global thread id or #f if there isn't one." },
{ "set-breakpoint-thread!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_thread_x),
"\
Set the global thread id for this breakpoint.\n\
\n\
Arguments: <gdb:breakpoint> global-thread-id" },
{ "breakpoint-task", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_task),
"\
Return the breakpoint's Ada task-id or #f if there isn't one." },
{ "set-breakpoint-task!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_task_x),
"\
Set the breakpoint's Ada task-id.\n\
\n\
Arguments: <gdb:breakpoint> task-id" },
{ "breakpoint-condition", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_condition),
"\
Return the breakpoint's condition as specified by the user.\n\
Return #f if there isn't one." },
{ "set-breakpoint-condition!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_condition_x),
"\
Set the breakpoint's condition.\n\
\n\
Arguments: <gdb:breakpoint> condition\n\
condition: a string" },
{ "breakpoint-stop", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_stop),
"\
Return the breakpoint's stop predicate.\n\
Return #f if there isn't one." },
{ "set-breakpoint-stop!", 2, 0, 0,
as_a_scm_t_subr (gdbscm_set_breakpoint_stop_x),
"\
Set the breakpoint's stop predicate.\n\
\n\
Arguments: <gdb:breakpoint> procedure\n\
procedure: A procedure of one argument, the breakpoint.\n\
Its result is true if program execution should stop." },
{ "breakpoint-commands", 1, 0, 0,
as_a_scm_t_subr (gdbscm_breakpoint_commands),
"\
Return the breakpoint's commands." },
END_FUNCTIONS
};
void
gdbscm_initialize_breakpoints (void)
{
breakpoint_smob_tag
= gdbscm_make_smob_type (breakpoint_smob_name, sizeof (breakpoint_smob));
scm_set_smob_free (breakpoint_smob_tag, bpscm_free_breakpoint_smob);
scm_set_smob_print (breakpoint_smob_tag, bpscm_print_breakpoint_smob);
gdb::observers::breakpoint_created.attach (bpscm_breakpoint_created);
gdb::observers::breakpoint_deleted.attach (bpscm_breakpoint_deleted);
gdbscm_define_integer_constants (breakpoint_integer_constants, 1);
gdbscm_define_functions (breakpoint_functions, 1);
type_keyword = scm_from_latin1_keyword ("type");
wp_class_keyword = scm_from_latin1_keyword ("wp-class");
internal_keyword = scm_from_latin1_keyword ("internal");
}