darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
old-cross-binutils/gdb/break-catch-throw.c
Keith Seitz f00aae0f7b Explicit locations: use new location API 
This patch converts the code base to use the new struct event_location
API being introduced. This patch preserves the current functionality and
adds no new features.

The "big picture" API usage introduced by this patch may be illustrated
with a simple exmaple. Where previously developers would write:

void
my_command (char *arg, int from_tty)
{
   create_breakpoint (..., arg, ...);
   ...
}

one now uses:

void
my_command (char *arg, int from_tty)
{
   struct event_locaiton *location;
   struct cleanup *back_to;

   location = string_to_event_locaiton (&arg, ...);
   back_to = make_cleanup_delete_event_location (location);
   create_breakpoint (..., location, ...);
   do_cleanups (back_to);
}

Linespec-decoding functions (now called location-decoding) such as
decode_line_full no longer skip argument pointers over processed input.
That functionality has been moved into string_to_event_location as
demonstrated above.

gdb/ChangeLog

	* ax-gdb.c: Include location.h.
	(agent_command_1) Use linespec location instead of address
	string.
	* break-catch-throw.c: Include location.h.
	(re_set_exception_catchpoint): Use linespec locations instead
	of address strings.
	* breakpoint.c: Include location.h.
	(create_overlay_event_breakpoint, create_longjmp_master_breakpoint)
	(create_std_terminate_master_breakpoint)
	(create_exception_master_breakpoint, update_breakpoints_after_exec):
	Use linespec location instead of address string.
	(print_breakpoint_location):  Use locations and
	event_location_to_string.
	Print extra_string for pending locations for non-MI streams.
	(print_one_breakpoint_location): Use locations and
	event_location_to_string.
	(init_raw_breakpoint_without_location): Initialize b->location.
	(create_thread_event_breakpoint): Use linespec location instead of
	address string.
	(init_breakpoint_sal): Likewise.
	Only save extra_string if it is non-NULL and not the empty string.
	Use event_location_to_string instead of `addr_string'.
	Constify `p' and `endp'.
	Use skip_spaces_const/skip_space_const instead of non-const versions.
	Copy the location into the breakpoint.
	If LOCATION is NULL, save the breakpoint address as a linespec location
	instead of an address string.
	(create_breakpoint_sal): Change `addr_string' parameter to a struct
	event_location. All uses updated.
	(create_breakpoints_sal): Likewise for local variable `addr_string'.
	(parse_breakpoint_sals): Use locations instead of address strings.
	Remove check for empty linespec with conditional.
	Refactor.
	(decode_static_tracepoint_spec): Make argument const and update
	function.
	(create_breakpoint): Change `arg' to a struct event_location and
	rename.
	Remove `copy_arg' and `addr_start'.
	If EXTRA_STRING is empty, set it to NULL.
	Don't populate `canonical' for pending breakpoints.
	Pass `extra_string' to find_condition_and_thread.
	Clear `extra_string' if `rest' was NULL.
	Do not error with "garbage after location" if setting a dprintf
	breakpoint.
	Copy the location into the breakpoint instead of an address string.
	(break_command_1): Use string_to_event_location and pass this to
	create_breakpoint instead of an address string.
	Check against `arg_cp' for a probe linespec.
	(dprintf_command): Use string_to_event_location and pass this to
	create_breakpoint instead of an address string.
	Throw an exception if no format string was specified.
	(print_recreate_ranged_breakpoint): Use event_location_to_string
	instead of address strings.
	(break_range_command, until_break_command)
	(init_ada_exception_breakpoint): Use locations instead
	of address strings.
	(say_where): Print out extra_string for pending locations.
	(base_breakpoint_dtor): Delete `location' and `location_range_end' of
	the breakpoint.
	(base_breakpoint_create_sals_from_location): Use struct event_location
	instead of address string.
	Remove `addr_start' and `copy_arg' parameters.
	(base_breakpoint_decode_location): Use struct event_location instead of
	address string.
	(bkpt_re_set): Use locations instead of address strings.
	Use event_location_empty_p to check for unset location.
	(bkpt_print_recreate): Use event_location_to_string instead of
	an address string.
	Print out extra_string for pending locations.
	(bkpt_create_sals_from_location, bkpt_decode_location)
 	(bkpt_probe_create_sals_from_location): Use struct event_location
	instead of address string.
	(bkpt_probe_decode_location): Use struct event_location instead of
	address string.
	(tracepoint_print_recreate): Use event_location_to_string to
	recreate the tracepoint.
	(tracepoint_create_sals_from_location, tracepoint_decode_location)
	(tracepoint_probe_create_sals_from_location)
	(tracepoint_probe_decode_location): Use struct event_location
	instead of address string.
	(dprintf_print_recreate): Use event_location_to_string to recreate
	the dprintf.
	(dprintf_re_set): Remove check for valid/missing format string.
	(strace_marker_create_sals_from_location)
	(strace_marker_create_breakpoints_sal, strace_marker_decode_location)
	(update_static_tracepoint): Use struct event_location instead of
	address string.
	(location_to_sals): Likewise.
	Pass `extra_string' to find_condition_and_thread.
	For newly resolved pending breakpoint locations, clear the location's
	string representation.
	Assert that the breakpoint's condition string is NULL when
	condition_not_parsed.
	(breakpoint_re_set_default, create_sals_from_location_default)
	(decode_location_default, trace_command, ftrace_command)
	(strace_command, create_tracepoint_from_upload): Use locations
	instead of address strings.
	* breakpoint.h (struct breakpoint_ops) <create_sals_from_location>:
	Use struct event_location instead of address string.
	Update all uses.
	<decode_location>: Likewise.
	(struct breakpoint) <addr_string>: Change to struct event_location
	and rename `location'.
	<addr_string_range_end>: Change to struct event_location and rename
	`location_range_end'.
	(create_breakpoint): Use struct event_location instead of address
	string.
	* cli/cli-cmds.c: Include location.h.
	(edit_command, list_command): Use locations instead of address strings.
	* elfread.c: Include location.h.
	(elf_gnu_ifunc_resolver_return_stop): Use event_location_to_string.
	* guile/scm-breakpoint.c: Include location.h.
	(bpscm_print_breakpoint_smob): Use event_location_to_string.
	(gdbscm_register_breakpoint): Use locations instead of address
	strings.
	* linespec.c: Include location.h.
	(struct ls_parser) <stream>: Change to const char *.
	(PARSER_STREAM): Update.
	(lionespec_lexer_lex_keyword): According to find_condition_and_thread,
	keywords must be followed by whitespace.
	(canonicalize_linespec): Save a linespec location into `canonical'.
	Save a canonical linespec into `canonical'.
	(parse_linespec): Change `argptr' to const char * and rename `arg'.
	All uses updated.
	Update function description.
	(linespec_parser_new): Initialize `parser'.
	Update initialization of  parsing stream.
	(event_location_to_sals): New function.
	(decode_line_full): Change `argptr' to a struct event_location and
	rename it `location'.
	Use locations instead of address strings.
	Call event_location_to_sals instead of parse_linespec.
	(decode_line_1): Likewise.
	(decode_line_with_current_source, decode_line_with_last_displayed)
	Use locations instead of address strings.
	(decode_objc): Likewise.
	Change `argptr' to const char * and rename `arg'.
	(destroy_linespec_result): Delete the linespec result's location
	instead of freeing the address string.
	* linespec.h (struct linespec_result) <addr_string>: Change to
	struct event_location and rename to ...
	<location>: ... this.
	(decode_line_1, decode_line_full): Change `argptr' to struct
	event_location.  All callers updated.
	* mi/mi-cmd-break.c: Include language.h, location.h, and linespec.h.
	(mi_cmd_break_insert_1): Use locations instead of address strings.
	Throw an error if there was "garbage" at the end of the specified
	linespec.
	* probe.c: Include location.h.
	(parse_probes): Change `argptr' to struct event_location.
	Use event locations instead of address strings.
	* probe.h (parse_probes): Change `argptr' to struct event_location.
	* python/py-breakpoint.c: Include location.h.
	(bppy_get_location): Constify local variable `str'.
	Use event_location_to_string.
	(bppy_init): Use locations instead of address strings.
	* python/py-finishbreakpoint.c: Include location.h.
	(bpfinishpy_init): Remove local variable `addr_str'.
	Use locations instead of address strings.
	* python/python.c: Include location.h.
	(gdbpy_decode_line): Use locations instead of address strings.
	* remote.c: Include location.h.
	(remote_download_tracepoint): Use locations instead of address
	strings.
	* spu-tdep.c: Include location.h.
	(spu_catch_start): Remove local variable `buf'.
	Use locations instead of address strings.
	* tracepoint.c: Include location.h.
	(scope_info): Use locations instead of address strings.
	(encode_source_string): Constify parameter `src'.
	* tracepoint.h (encode_source_string): Likewise.

gdb/testsuite/ChangeLog

	* gdb.base/dprintf-pending.exp: Update dprintf "without format"
	test.
	Add tests for missing ",FMT" and ",".
2015-08-11 17:09:35 -07:00

608 lines
16 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Everything about catch/throw catchpoints, for GDB.
Copyright (C) 1986-2015 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/>. */
#include "defs.h"
#include "arch-utils.h"
#include <ctype.h>
#include "breakpoint.h"
#include "gdbcmd.h"
#include "inferior.h"
#include "annotate.h"
#include "valprint.h"
#include "cli/cli-utils.h"
#include "completer.h"
#include "gdb_obstack.h"
#include "mi/mi-common.h"
#include "linespec.h"
#include "probe.h"
#include "objfiles.h"
#include "cp-abi.h"
#include "gdb_regex.h"
#include "cp-support.h"
#include "location.h"
/* Enums for exception-handling support. */
enum exception_event_kind
{
EX_EVENT_THROW,
EX_EVENT_RETHROW,
EX_EVENT_CATCH
};
/* Each spot where we may place an exception-related catchpoint has
two names: the SDT probe point and the function name. This
structure holds both. */
struct exception_names
{
/* The name of the probe point to try, in the form accepted by
'parse_probes'. */
const char *probe;
/* The name of the corresponding function. */
const char *function;
};
/* Names of the probe points and functions on which to break. This is
indexed by exception_event_kind. */
static const struct exception_names exception_functions[] =
{
{ "-probe-stap libstdcxx:throw", "__cxa_throw" },
{ "-probe-stap libstdcxx:rethrow", "__cxa_rethrow" },
{ "-probe-stap libstdcxx:catch", "__cxa_begin_catch" }
};
static struct breakpoint_ops gnu_v3_exception_catchpoint_ops;
/* The type of an exception catchpoint. */
struct exception_catchpoint
{
/* The base class. */
struct breakpoint base;
/* The kind of exception catchpoint. */
enum exception_event_kind kind;
/* If non-NULL, an xmalloc'd string holding the source form of the
regular expression to match against. */
char *exception_rx;
/* If non-NULL, an xmalloc'd, compiled regular expression which is
used to determine which exceptions to stop on. */
regex_t *pattern;
};
/* A helper function that fetches exception probe arguments. This
fills in *ARG0 (if non-NULL) and *ARG1 (which must be non-NULL).
It will throw an exception on any kind of failure. */
static void
fetch_probe_arguments (struct value **arg0, struct value **arg1)
{
struct frame_info *frame = get_selected_frame (_("No frame selected"));
CORE_ADDR pc = get_frame_pc (frame);
struct bound_probe pc_probe;
const struct sym_probe_fns *pc_probe_fns;
unsigned n_args;
pc_probe = find_probe_by_pc (pc);
if (pc_probe.probe == NULL
|| strcmp (pc_probe.probe->provider, "libstdcxx") != 0
|| (strcmp (pc_probe.probe->name, "catch") != 0
&& strcmp (pc_probe.probe->name, "throw") != 0
&& strcmp (pc_probe.probe->name, "rethrow") != 0))
error (_("not stopped at a C++ exception catchpoint"));
n_args = get_probe_argument_count (pc_probe.probe, frame);
if (n_args < 2)
error (_("C++ exception catchpoint has too few arguments"));
if (arg0 != NULL)
*arg0 = evaluate_probe_argument (pc_probe.probe, 0, frame);
*arg1 = evaluate_probe_argument (pc_probe.probe, 1, frame);
if ((arg0 != NULL && *arg0 == NULL) || *arg1 == NULL)
error (_("error computing probe argument at c++ exception catchpoint"));
}
/* A helper function that returns a value indicating the kind of the
exception catchpoint B. */
static enum exception_event_kind
classify_exception_breakpoint (struct breakpoint *b)
{
struct exception_catchpoint *cp = (struct exception_catchpoint *) b;
return cp->kind;
}
/* Implement the 'dtor' method. */
static void
dtor_exception_catchpoint (struct breakpoint *self)
{
struct exception_catchpoint *cp = (struct exception_catchpoint *) self;
xfree (cp->exception_rx);
if (cp->pattern != NULL)
regfree (cp->pattern);
bkpt_breakpoint_ops.dtor (self);
}
/* Implement the 'check_status' method. */
static void
check_status_exception_catchpoint (struct bpstats *bs)
{
struct exception_catchpoint *self
= (struct exception_catchpoint *) bs->breakpoint_at;
char *type_name = NULL;
bkpt_breakpoint_ops.check_status (bs);
if (bs->stop == 0)
return;
if (self->pattern == NULL)
return;
TRY
{
struct value *typeinfo_arg;
char *canon;
fetch_probe_arguments (NULL, &typeinfo_arg);
type_name = cplus_typename_from_type_info (typeinfo_arg);
canon = cp_canonicalize_string (type_name);
if (canon != NULL)
{
xfree (type_name);
type_name = canon;
}
}
CATCH (e, RETURN_MASK_ERROR)
{
exception_print (gdb_stderr, e);
}
END_CATCH
if (type_name != NULL)
{
if (regexec (self->pattern, type_name, 0, NULL, 0) != 0)
bs->stop = 0;
xfree (type_name);
}
}
/* Implement the 're_set' method. */
static void
re_set_exception_catchpoint (struct breakpoint *self)
{
struct symtabs_and_lines sals = {0};
struct symtabs_and_lines sals_end = {0};
struct cleanup *cleanup;
enum exception_event_kind kind = classify_exception_breakpoint (self);
struct event_location *location;
/* We first try to use the probe interface. */
TRY
{
char *spec = ASTRDUP (exception_functions[kind].probe);
location = new_linespec_location (&spec);
cleanup = make_cleanup_delete_event_location (location);
sals = parse_probes (location, NULL);
do_cleanups (cleanup);
}
CATCH (e, RETURN_MASK_ERROR)
{
/* Using the probe interface failed. Let's fallback to the normal
catchpoint mode. */
TRY
{
char *spec = ASTRDUP (exception_functions[kind].function);
location = new_linespec_location (&spec);
cleanup = make_cleanup_delete_event_location (location);
self->ops->decode_location (self, location, &sals);
do_cleanups (cleanup);
}
CATCH (ex, RETURN_MASK_ERROR)
{
/* NOT_FOUND_ERROR just means the breakpoint will be
pending, so let it through. */
if (ex.error != NOT_FOUND_ERROR)
throw_exception (ex);
}
END_CATCH
}
END_CATCH
cleanup = make_cleanup (xfree, sals.sals);
update_breakpoint_locations (self, sals, sals_end);
do_cleanups (cleanup);
}
static enum print_stop_action
print_it_exception_catchpoint (bpstat bs)
{
struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
int bp_temp;
enum exception_event_kind kind = classify_exception_breakpoint (b);
annotate_catchpoint (b->number);
bp_temp = b->disposition == disp_del;
ui_out_text (uiout,
bp_temp ? "Temporary catchpoint "
: "Catchpoint ");
if (!ui_out_is_mi_like_p (uiout))
ui_out_field_int (uiout, "bkptno", b->number);
ui_out_text (uiout,
(kind == EX_EVENT_THROW ? " (exception thrown), "
: (kind == EX_EVENT_CATCH ? " (exception caught), "
: " (exception rethrown), ")));
if (ui_out_is_mi_like_p (uiout))
{
ui_out_field_string (uiout, "reason",
async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
ui_out_field_int (uiout, "bkptno", b->number);
}
return PRINT_SRC_AND_LOC;
}
static void
print_one_exception_catchpoint (struct breakpoint *b,
struct bp_location **last_loc)
{
struct value_print_options opts;
struct ui_out *uiout = current_uiout;
enum exception_event_kind kind = classify_exception_breakpoint (b);
get_user_print_options (&opts);
if (opts.addressprint)
{
annotate_field (4);
if (b->loc == NULL || b->loc->shlib_disabled)
ui_out_field_string (uiout, "addr", "<PENDING>");
else
ui_out_field_core_addr (uiout, "addr",
b->loc->gdbarch, b->loc->address);
}
annotate_field (5);
if (b->loc)
*last_loc = b->loc;
switch (kind)
{
case EX_EVENT_THROW:
ui_out_field_string (uiout, "what", "exception throw");
if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "catch-type", "throw");
break;
case EX_EVENT_RETHROW:
ui_out_field_string (uiout, "what", "exception rethrow");
if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "catch-type", "rethrow");
break;
case EX_EVENT_CATCH:
ui_out_field_string (uiout, "what", "exception catch");
if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "catch-type", "catch");
break;
}
}
/* Implement the 'print_one_detail' method. */
static void
print_one_detail_exception_catchpoint (const struct breakpoint *b,
struct ui_out *uiout)
{
const struct exception_catchpoint *cp
= (const struct exception_catchpoint *) b;
if (cp->exception_rx != NULL)
{
ui_out_text (uiout, _("\tmatching: "));
ui_out_field_string (uiout, "regexp", cp->exception_rx);
ui_out_text (uiout, "\n");
}
}
static void
print_mention_exception_catchpoint (struct breakpoint *b)
{
struct ui_out *uiout = current_uiout;
int bp_temp;
enum exception_event_kind kind = classify_exception_breakpoint (b);
bp_temp = b->disposition == disp_del;
ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
: _("Catchpoint "));
ui_out_field_int (uiout, "bkptno", b->number);
ui_out_text (uiout, (kind == EX_EVENT_THROW ? _(" (throw)")
: (kind == EX_EVENT_CATCH ? _(" (catch)")
: _(" (rethrow)"))));
}
/* Implement the "print_recreate" breakpoint_ops method for throw and
catch catchpoints. */
static void
print_recreate_exception_catchpoint (struct breakpoint *b,
struct ui_file *fp)
{
int bp_temp;
enum exception_event_kind kind = classify_exception_breakpoint (b);
bp_temp = b->disposition == disp_del;
fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
switch (kind)
{
case EX_EVENT_THROW:
fprintf_unfiltered (fp, "throw");
break;
case EX_EVENT_CATCH:
fprintf_unfiltered (fp, "catch");
break;
case EX_EVENT_RETHROW:
fprintf_unfiltered (fp, "rethrow");
break;
}
print_recreate_thread (b, fp);
}
static void
handle_gnu_v3_exceptions (int tempflag, char *except_rx, char *cond_string,
enum exception_event_kind ex_event, int from_tty)
{
struct exception_catchpoint *cp;
struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
regex_t *pattern = NULL;
if (except_rx != NULL)
{
pattern = XNEW (regex_t);
make_cleanup (xfree, pattern);
compile_rx_or_error (pattern, except_rx,
_("invalid type-matching regexp"));
}
cp = XCNEW (struct exception_catchpoint);
make_cleanup (xfree, cp);
init_catchpoint (&cp->base, get_current_arch (), tempflag, cond_string,
&gnu_v3_exception_catchpoint_ops);
/* We need to reset 'type' in order for code in breakpoint.c to do
the right thing. */
cp->base.type = bp_breakpoint;
cp->kind = ex_event;
cp->exception_rx = except_rx;
cp->pattern = pattern;
re_set_exception_catchpoint (&cp->base);
install_breakpoint (0, &cp->base, 1);
discard_cleanups (cleanup);
}
/* Look for an "if" token in *STRING. The "if" token must be preceded
by whitespace.
If there is any non-whitespace text between *STRING and the "if"
token, then it is returned in a newly-xmalloc'd string. Otherwise,
this returns NULL.
STRING is updated to point to the "if" token, if it exists, or to
the end of the string. */
static char *
extract_exception_regexp (char **string)
{
char *start;
char *last, *last_space;
start = skip_spaces (*string);
last = start;
last_space = start;
while (*last != '\0')
{
char *if_token = last;
/* Check for the "if". */
if (check_for_argument (&if_token, "if", 2))
break;
/* No "if" token here. Skip to the next word start. */
last_space = skip_to_space (last);
last = skip_spaces (last_space);
}
*string = last;
if (last_space > start)
return savestring (start, last_space - start);
return NULL;
}
/* Deal with "catch catch", "catch throw", and "catch rethrow"
commands. */
static void
catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
int tempflag, int from_tty)
{
char *except_rx;
char *cond_string = NULL;
struct cleanup *cleanup;
if (!arg)
arg = "";
arg = skip_spaces (arg);
except_rx = extract_exception_regexp (&arg);
cleanup = make_cleanup (xfree, except_rx);
cond_string = ep_parse_optional_if_clause (&arg);
if ((*arg != '\0') && !isspace (*arg))
error (_("Junk at end of arguments."));
if (ex_event != EX_EVENT_THROW
&& ex_event != EX_EVENT_CATCH
&& ex_event != EX_EVENT_RETHROW)
error (_("Unsupported or unknown exception event; cannot catch it"));
handle_gnu_v3_exceptions (tempflag, except_rx, cond_string,
ex_event, from_tty);
discard_cleanups (cleanup);
}
/* Implementation of "catch catch" command. */
static void
catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
{
int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
}
/* Implementation of "catch throw" command. */
static void
catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
{
int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
}
/* Implementation of "catch rethrow" command. */
static void
catch_rethrow_command (char *arg, int from_tty,
struct cmd_list_element *command)
{
int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
catch_exception_command_1 (EX_EVENT_RETHROW, arg, tempflag, from_tty);
}
/* Implement the 'make_value' method for the $_exception
internalvar. */
static struct value *
compute_exception (struct gdbarch *argc, struct internalvar *var, void *ignore)
{
struct value *arg0, *arg1;
struct type *obj_type;
fetch_probe_arguments (&arg0, &arg1);
/* ARG0 is a pointer to the exception object. ARG1 is a pointer to
the std::type_info for the exception. Now we find the type from
the type_info and cast the result. */
obj_type = cplus_type_from_type_info (arg1);
return value_ind (value_cast (make_pointer_type (obj_type, NULL), arg0));
}
/* Implementation of the '$_exception' variable. */
static const struct internalvar_funcs exception_funcs =
{
compute_exception,
NULL,
NULL
};
static void
initialize_throw_catchpoint_ops (void)
{
struct breakpoint_ops *ops;
initialize_breakpoint_ops ();
/* GNU v3 exception catchpoints. */
ops = &gnu_v3_exception_catchpoint_ops;
*ops = bkpt_breakpoint_ops;
ops->dtor = dtor_exception_catchpoint;
ops->re_set = re_set_exception_catchpoint;
ops->print_it = print_it_exception_catchpoint;
ops->print_one = print_one_exception_catchpoint;
ops->print_mention = print_mention_exception_catchpoint;
ops->print_recreate = print_recreate_exception_catchpoint;
ops->print_one_detail = print_one_detail_exception_catchpoint;
ops->check_status = check_status_exception_catchpoint;
}
initialize_file_ftype _initialize_break_catch_throw;
void
_initialize_break_catch_throw (void)
{
initialize_throw_catchpoint_ops ();
/* Add catch and tcatch sub-commands. */
add_catch_command ("catch", _("\
Catch an exception, when caught."),
catch_catch_command,
NULL,
CATCH_PERMANENT,
CATCH_TEMPORARY);
add_catch_command ("throw", _("\
Catch an exception, when thrown."),
catch_throw_command,
NULL,
CATCH_PERMANENT,
CATCH_TEMPORARY);
add_catch_command ("rethrow", _("\
Catch an exception, when rethrown."),
catch_rethrow_command,
NULL,
CATCH_PERMANENT,
CATCH_TEMPORARY);
create_internalvar_type_lazy ("_exception", &exception_funcs, NULL);
}
Reference in a new issue View git blame Copy permalink