From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2436 invoked by alias); 15 Jun 2019 22:34:29 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 2428 invoked by uid 89); 15 Jun 2019 22:34:29 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.7 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.1 spammy=Deal, sk:break-c, sk:breakc, H*f:sk:2019051 X-HELO: mail-wr1-f45.google.com Received: from mail-wr1-f45.google.com (HELO mail-wr1-f45.google.com) (209.85.221.45) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 15 Jun 2019 22:34:23 +0000 Received: by mail-wr1-f45.google.com with SMTP id d18so6059498wrs.5 for ; Sat, 15 Jun 2019 15:34:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=date:from:to:subject:message-id:references:mime-version :content-disposition:in-reply-to:user-agent; bh=TIZDKNS10zTyKbYVZuZ0cst9IywyiaSThXyuo8oR6CI=; b=F4TszdG8WEXfH+6w8CTvR/GFJxeGtTb/+2efZBfExCCWPYDaI6xu5Wnv+zpN0T/Iqp mR7D1nGtNeATgH9MquzKpt9mBU9X4vqrVf3wQKqQe3MwkdfoO3YfIFTUULcK8IdBDdip Y+37RGsfmABwt5CfmTCeaD4W1wAgkxhphuSxbyOiPIHyonaAeHNKEgQ3naO1RARKa4xX +MCqUrJCgi57Hz8IQDMXG+Z89RO9ZedO8mw1tF+p4sgouGhJInaT7sYjOvLgA9kPl7kN aXJLvIjJVZpn/mBZvOGV+Mr3DbX11OnwWTJ9f4pMz2qONy6PSzxub+2/nvJXYbRD0dWb G8tA== Return-Path: Received: from localhost (host86-180-62-212.range86-180.btcentralplus.com. [86.180.62.212]) by smtp.gmail.com with ESMTPSA id x6sm8447312wru.0.2019.06.15.15.34.19 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Sat, 15 Jun 2019 15:34:19 -0700 (PDT) Date: Sat, 15 Jun 2019 22:34:00 -0000 From: Andrew Burgess To: gdb-patches@sourceware.org Subject: Re: [PATCHv2] gdb/mi: New commands to catch C++ exceptions Message-ID: <20190615223418.GA23204@embecosm.com> References: <20190509000500.20536-1-andrew.burgess@embecosm.com> <20190511234646.4992-1-andrew.burgess@embecosm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190511234646.4992-1-andrew.burgess@embecosm.com> X-Fortune: Write-only-memory subsystem too slow for this machine. Contact your local dealer. X-Editor: GNU Emacs [ http://www.gnu.org/software/emacs ] User-Agent: Mutt/1.9.2 (2017-12-15) X-IsSubscribed: yes X-SW-Source: 2019-06/txt/msg00280.txt.bz2 * Andrew Burgess [2019-05-12 00:46:46 +0100]: > Eli, > > This iteration includes updated documentation that fixes almost all of > the issues you raised. The only thing I haven't done is collapse all > of the command sub-sections into a single sub-section. I looked > through most of the existing MI commands and they all seem to be one > command per sub-section, so I wasn't entirely sure how to layout a > merged entry, nor if a merged entry was inline with the style for MI > commands. > > --- > > I have also tweaked the code a little in this version, the changes > around how a catchpoint is reported when it is initially setup has > changed, the output is not more inline with other breakpoints. See > the changes in print_mention_exception_catchpoint, and the new > scoped_restore restore_breakpoint_reporting in > mi_cmd_catch_exception_event. Otherwise the code is unchanged. > > Thanks, > Andrew > > --- > > Adds some MI commands to catch C++ exceptions. The new commands are > -catch-throw, -catch-rethrow, and -catch-catch, these all correspond > to the CLI commands 'catch throw', 'catch rethrow', and 'catch catch'. > > Each MI command takes two optional arguments, '-t' has the effect of > calling 'tcatch' instead of 'catch', for example: > > (gdb) > -catch-throw -t > > Is the same as: > > (gdb) tcatch throw > > There is also a '-r REGEXP' argument that can supply a regexp to match > against the exception type, so: > > (gdb) > -catch-catch -r PATTERN > > Is the same as: > > (gdb) catch catch PATTERN > > The change in print_mention_exception_catchpoint might seem a little > strange; changing the output from using ui_out::field_int and > ui_out::text to using ui_out::message. > > The print_mention_exception_catchpoint is used as the 'print_mention' > method for the exception catchpoint breakpoint object. Most of the > other 'print_mention' methods (see breakpoint.c) use either > printf_filtered, of ui_out::message. Using field_int was causing an > unexpected field to be added to the MI output. Here's the output > without the change in print_mention_exception_catchpoint: > > (gdb) > -catch-throw > ^done,bkptno="1",bkpt={number="1",type="breakpoint",disp="keep", > enabled="y",addr="0x00000000004006c0", > what="exception throw",catch-type="throw", > thread-groups=["i1"],times="0"} > > Notice the breakpoint number appears in both the 'bkptno' field, and > the 'number' field within the 'bkpt' tuple. Here's the output with > the change in print_mention_exception_catchpoint: > > (gdb) > -catch-throw > ^done,bkpt={number="1",type="breakpoint",disp="keep", > enabled="y",addr="0x00000000004006c0", > what="exception throw",catch-type="throw", > thread-groups=["i1"],times="0"} > > gdb/ChangeLog: > > * NEWS: Mention new MI commands. > * break-catch-throw.c (enum exception_event_kind): Move to > breakpoint.h. > (print_mention_exception_catchpoint): Output text as a single > message. > (catch_exception_command_1): Rename to... > (catch_exception_event): ...this, make non-static, update header > command, and change some parameter types. > (catch_catch_command): Update for changes to > catch_exception_command_1. > (catch_throw_command): Likewise. > (catch_rethrow_command): Likewise. > * breakpoint.c (enum exception_event_kind): Delete. > * breakpoint.h (enum exception_event_kind): Moved here from > break-catch-throw.c. > (catch_exception_event): Declare. > * mi/mi-cmd-catch.c (mi_cmd_catch_exception_event): New function. > (mi_cmd_catch_throw): New function. > (mi_cmd_catch_rethrow): New function. > (mi_cmd_catch_catch): New function. > * mi/mi-cmds.c (mi_cmds): Add 'catch-throw', 'catch-rethrow', and > 'catch-catch' entries. > * mi/mi-cmds.h (mi_cmd_catch_throw): Declare. > (mi_cmd_catch_rethrow): Declare. > (mi_cmd_catch_catch): Declare. > > gdb/doc/ChangeLog: > > * gdb.texinfo (GDB/MI Catchpoint Commands): Add menu entry to new > node. > (C++ Exception GDB/MI Catchpoint Commands): New node to describe > new MI commands. > > gdb/testsuite/ChangeLog: > > * gdb.mi/mi-catch-cpp-exceptions.cc: New file. > * gdb.mi/mi-catch-cpp-exceptions.exp: New file. > * lib/mi-support.exp (mi_expect_stop): Handle 'exception-caught' > as a stop reason. I've now pushed this patch with the doc fixes that Eli suggested. Thanks, Andrew > --- > gdb/ChangeLog | 28 ++++ > gdb/NEWS | 4 + > gdb/break-catch-throw.c | 42 ++--- > gdb/breakpoint.c | 8 - > gdb/breakpoint.h | 20 +++ > gdb/doc/ChangeLog | 7 + > gdb/doc/gdb.texinfo | 140 ++++++++++++++++ > gdb/mi/mi-cmd-catch.c | 71 ++++++++ > gdb/mi/mi-cmds.c | 6 + > gdb/mi/mi-cmds.h | 3 + > gdb/testsuite/ChangeLog | 7 + > gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.cc | 73 +++++++++ > gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.exp | 197 +++++++++++++++++++++++ > gdb/testsuite/lib/mi-support.exp | 11 +- > 14 files changed, 580 insertions(+), 37 deletions(-) > create mode 100644 gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.cc > create mode 100644 gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.exp > > diff --git a/gdb/NEWS b/gdb/NEWS > index 288615b8cd3..3377940e2b2 100644 > --- a/gdb/NEWS > +++ b/gdb/NEWS > @@ -27,6 +27,10 @@ > 'array_indexes', 'symbols', 'unions', 'deref_refs', 'actual_objects', > 'static_members', 'max_elements', 'repeat_threshold', and 'format'. > > +* MI changes > + > + ** New commands -catch-throw, -catch-rethrow, and -catch-catch. > + > * New commands > > set may-call-functions [on|off] > diff --git a/gdb/break-catch-throw.c b/gdb/break-catch-throw.c > index a221cb31518..107ac74f5cc 100644 > --- a/gdb/break-catch-throw.c > +++ b/gdb/break-catch-throw.c > @@ -37,14 +37,6 @@ > #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. */ > @@ -317,12 +309,12 @@ print_mention_exception_catchpoint (struct breakpoint *b) > enum exception_event_kind kind = classify_exception_breakpoint (b); > > bp_temp = b->disposition == disp_del; > - uiout->text (bp_temp ? _("Temporary catchpoint ") > - : _("Catchpoint ")); > - uiout->field_int ("bkptno", b->number); > - uiout->text ((kind == EX_EVENT_THROW ? _(" (throw)") > - : (kind == EX_EVENT_CATCH ? _(" (catch)") > - : _(" (rethrow)")))); > + uiout->message ("%s %d %s", > + (bp_temp ? _("Temporary catchpoint ") : _("Catchpoint")), > + b->number, > + (kind == EX_EVENT_THROW > + ? _("(throw)") : (kind == EX_EVENT_CATCH > + ? _("(catch)") : _("(rethrow)")))); > } > > /* Implement the "print_recreate" breakpoint_ops method for throw and > @@ -420,13 +412,11 @@ extract_exception_regexp (const char **string) > return std::string (); > } > > -/* Deal with "catch catch", "catch throw", and "catch rethrow" > - commands. */ > +/* See breakpoint.h. */ > > -static void > -catch_exception_command_1 (enum exception_event_kind ex_event, > - const char *arg, > - int tempflag, int from_tty) > +void > +catch_exception_event (enum exception_event_kind ex_event, > + const char *arg, bool tempflag, int from_tty) > { > const char *cond_string = NULL; > > @@ -456,9 +446,9 @@ static void > catch_catch_command (const char *arg, int from_tty, > struct cmd_list_element *command) > { > - int tempflag = get_cmd_context (command) == CATCH_TEMPORARY; > + bool tempflag = get_cmd_context (command) == CATCH_TEMPORARY; > > - catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty); > + catch_exception_event (EX_EVENT_CATCH, arg, tempflag, from_tty); > } > > /* Implementation of "catch throw" command. */ > @@ -467,9 +457,9 @@ static void > catch_throw_command (const char *arg, int from_tty, > struct cmd_list_element *command) > { > - int tempflag = get_cmd_context (command) == CATCH_TEMPORARY; > + bool tempflag = get_cmd_context (command) == CATCH_TEMPORARY; > > - catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty); > + catch_exception_event (EX_EVENT_THROW, arg, tempflag, from_tty); > } > > /* Implementation of "catch rethrow" command. */ > @@ -478,9 +468,9 @@ static void > catch_rethrow_command (const char *arg, int from_tty, > struct cmd_list_element *command) > { > - int tempflag = get_cmd_context (command) == CATCH_TEMPORARY; > + bool tempflag = get_cmd_context (command) == CATCH_TEMPORARY; > > - catch_exception_command_1 (EX_EVENT_RETHROW, arg, tempflag, from_tty); > + catch_exception_event (EX_EVENT_RETHROW, arg, tempflag, from_tty); > } > > > diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c > index 35da97bd041..7b0fbdd01be 100644 > --- a/gdb/breakpoint.c > +++ b/gdb/breakpoint.c > @@ -85,14 +85,6 @@ > #include "common/array-view.h" > #include "common/gdb_optional.h" > > -/* Enums for exception-handling support. */ > -enum exception_event_kind > -{ > - EX_EVENT_THROW, > - EX_EVENT_RETHROW, > - EX_EVENT_CATCH > -}; > - > /* Prototypes for local functions. */ > > static void map_breakpoint_numbers (const char *, > diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h > index a91e3e334cf..c404d0e8ee8 100644 > --- a/gdb/breakpoint.h > +++ b/gdb/breakpoint.h > @@ -42,6 +42,16 @@ struct linespec_result; > struct linespec_sals; > struct inferior; > > +/* Enum for exception-handling support in 'catch throw', 'catch rethrow', > + 'catch catch' and the MI equivalent. */ > + > +enum exception_event_kind > +{ > + EX_EVENT_THROW, > + EX_EVENT_RETHROW, > + EX_EVENT_CATCH > +}; > + > /* Why are we removing the breakpoint from the target? */ > > enum remove_bp_reason > @@ -1670,4 +1680,14 @@ extern void print_breakpoint (breakpoint *bp); > /* Command element for the 'commands' command. */ > extern cmd_list_element *commands_cmd_element; > > +/* Deal with "catch catch", "catch throw", and "catch rethrow" commands and > + the MI equivalents. Sets up to catch events of type EX_EVENT. When > + TEMPFLAG is true only the next matching event is caught after which the > + catch-point is deleted. If REGEX is not NULL then only exceptions whose > + type name matches REGEX will trigger the event. */ > + > +extern void catch_exception_event (enum exception_event_kind ex_event, > + const char *regex, bool tempflag, > + int from_tty); > + > #endif /* !defined (BREAKPOINT_H) */ > diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo > index b7f3b271d1f..14d834eb488 100644 > --- a/gdb/doc/gdb.texinfo > +++ b/gdb/doc/gdb.texinfo > @@ -29406,6 +29406,7 @@ > @menu > * Shared Library GDB/MI Catchpoint Commands:: > * Ada Exception GDB/MI Catchpoint Commands:: > +* C++ Exception GDB/MI Catchpoint Commands:: > @end menu > > @node Shared Library GDB/MI Catchpoint Commands > @@ -29605,6 +29606,145 @@ > (gdb) > @end smallexample > > +@node C++ Exception GDB/MI Catchpoint Commands > +@subsection C@t{++} Exception @sc{gdb/mi} Catchpoints > + > +The following @sc{gdb/mi} commands can be used to create catchpoints > +that stop the execution when C@t{++} exceptions are being throw, rethrown, > +or caught.. > + > +@subheading The @code{-catch-throw} Command > +@findex -catch-throw > + > +@subsubheading Synopsis > + > +@smallexample > + -catch-throw [ -t ] [ -r @var{regexp}] > +@end smallexample > + > +Stop when the debuggee throws a C@t{++} exception. If @var{regexp} is > +given, then only exceptions whose type matches the regular expression > +will be caught. > + > +If @samp{-t} is given, then the catchpoint is enabled only for one > +stop, the catchpoint is automatically deleted after stopping once for > +the event. > + > +@subsubheading @value{GDBN} Command > + > +The corresponding @value{GDBN} commands are @samp{catch throw} > +and @samp{tcatch throw} (@pxref{Set Catchpoints}). > + > +@subsubheading Example > + > +@smallexample > +-catch-throw -r exception_type > +^done,bkpt=@{number="1",type="breakpoint",disp="keep",enabled="y", > + addr="0x00000000004006c0",what="exception throw", > + catch-type="throw",thread-groups=["i1"], > + regexp="exception_type",times="0"@} > +(gdb) > +-exec-run > +^running > +(gdb) > +~"\n" > +~"Catchpoint 1 (exception thrown), 0x00007ffff7ae00ed > + in __cxa_throw () from /lib64/libstdc++.so.6\n" > +*stopped,bkptno="1",reason="breakpoint-hit",disp="keep", > + frame=@{addr="0x00007ffff7ae00ed",func="__cxa_throw", > + args=[],from="/lib64/libstdc++.so.6",arch="i386:x86-64"@}, > + thread-id="1",stopped-threads="all",core="6" > +(gdb) > +@end smallexample > + > +@subheading The @code{-catch-rethrow} Command > +@findex -catch-rethrow > + > +@subsubheading Synopsis > + > +@smallexample > + -catch-rethrow [ -t ] [ -r @var{regexp}] > +@end smallexample > + > +Stop when a C@t{++} exception is re-thrown. If @var{regexp} is given, > +then only exceptions whose type matches the regular expression will be > +caught. > + > +If @samp{-t} is given, then the catchpoint is enabled only for one > +stop, the catchpoint is automatically deleted after the first event is > +caught. > + > +@subsubheading @value{GDBN} Command > + > +The corresponding @value{GDBN} commands are @samp{catch rethrow} > +and @samp{tcatch rethrow} (@pxref{Set Catchpoints}). > + > +@subsubheading Example > + > +@smallexample > +-catch-rethrow -r exception_type > +^done,bkpt=@{number="1",type="breakpoint",disp="keep",enabled="y", > + addr="0x00000000004006c0",what="exception rethrow", > + catch-type="rethrow",thread-groups=["i1"], > + regexp="exception_type",times="0"@} > +(gdb) > +-exec-run > +^running > +(gdb) > +~"\n" > +~"Catchpoint 1 (exception thrown), 0x00007ffff7ae00ed > + in __cxa_throw () from /lib64/libstdc++.so.6\n" > +*stopped,bkptno="1",reason="breakpoint-hit",disp="keep", > + frame=@{addr="0x00007ffff7ae00ed",func="__cxa_throw", > + args=[],from="/lib64/libstdc++.so.6",arch="i386:x86-64"@}, > + thread-id="1",stopped-threads="all",core="6" > +(gdb) > +@end smallexample > + > +@subheading The @code{-catch-catch} Command > +@findex -catch-catch > + > +@subsubheading Synopsis > + > +@smallexample > + -catch-catch [ -t ] [ -r @var{regexp}] > +@end smallexample > + > +Stop when the debuggee catches a C@t{++} exception. If @var{regexp} > +is given, then only exceptions whose type matches the regular > +expression will be caught. > + > +If @samp{-t} is given, then the catchpoint is enabled only for one > +stop, the catchpoint is automatically deleted after the first event is > +caught. > + > +@subsubheading @value{GDBN} Command > + > +The corresponding @value{GDBN} commands are @samp{catch catch} > +and @samp{tcatch catch} (@pxref{Set Catchpoints}). > + > +@subsubheading Example > + > +@smallexample > +-catch-catch -r exception_type > +^done,bkpt=@{number="1",type="breakpoint",disp="keep",enabled="y", > + addr="0x00000000004006c0",what="exception catch", > + catch-type="catch",thread-groups=["i1"], > + regexp="exception_type",times="0"@} > +(gdb) > +-exec-run > +^running > +(gdb) > +~"\n" > +~"Catchpoint 1 (exception thrown), 0x00007ffff7ae00ed > + in __cxa_throw () from /lib64/libstdc++.so.6\n" > +*stopped,bkptno="1",reason="breakpoint-hit",disp="keep", > + frame=@{addr="0x00007ffff7ae00ed",func="__cxa_throw", > + args=[],from="/lib64/libstdc++.so.6",arch="i386:x86-64"@}, > + thread-id="1",stopped-threads="all",core="6" > +(gdb) > +@end smallexample > + > @c %%%%%%%%%%%%%%%%%%%%%%%%%%%% SECTION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% > @node GDB/MI Program Context > @section @sc{gdb/mi} Program Context > diff --git a/gdb/mi/mi-cmd-catch.c b/gdb/mi/mi-cmd-catch.c > index 87929c48ca4..a044fe4472c 100644 > --- a/gdb/mi/mi-cmd-catch.c > +++ b/gdb/mi/mi-cmd-catch.c > @@ -288,3 +288,74 @@ mi_cmd_catch_unload (const char *cmd, char *argv[], int argc) > mi_catch_load_unload (0, argv, argc); > } > > +/* Core handler for -catch-throw, -catch-rethrow, and -catch-catch > + commands. The argument handling for all of these is identical, we just > + pass KIND through to GDB's core to select the correct event type. */ > + > +static void > +mi_cmd_catch_exception_event (enum exception_event_kind kind, > + const char *cmd, char *argv[], int argc) > +{ > + char *regex = NULL; > + bool temp = false; > + int oind = 0; > + char *oarg; > + enum opt > + { > + OPT_TEMP, > + OPT_REGEX, > + }; > + static const struct mi_opt opts[] = > + { > + { "t", OPT_TEMP, 0 }, > + { "r", OPT_REGEX, 1 }, > + { 0, 0, 0 } > + }; > + > + for (;;) > + { > + int opt = mi_getopt (cmd, argc, argv, opts, > + &oind, &oarg); > + > + if (opt < 0) > + break; > + > + switch ((enum opt) opt) > + { > + case OPT_TEMP: > + temp = true; > + break; > + case OPT_REGEX: > + regex = oarg; > + break; > + } > + } > + > + scoped_restore restore_breakpoint_reporting = setup_breakpoint_reporting (); > + catch_exception_event (kind, regex, temp, 0 /* from_tty */); > +} > + > +/* Handler for -catch-throw. */ > + > +void > +mi_cmd_catch_throw (const char *cmd, char *argv[], int argc) > +{ > + mi_cmd_catch_exception_event (EX_EVENT_THROW, cmd, argv, argc); > +} > + > +/* Handler for -catch-rethrow. */ > + > +void > +mi_cmd_catch_rethrow (const char *cmd, char *argv[], int argc) > +{ > + mi_cmd_catch_exception_event (EX_EVENT_RETHROW, cmd, argv, argc); > +} > + > +/* Handler for -catch-catch. */ > + > +void > +mi_cmd_catch_catch (const char *cmd, char *argv[], int argc) > +{ > + mi_cmd_catch_exception_event (EX_EVENT_CATCH, cmd, argv, argc); > +} > + > diff --git a/gdb/mi/mi-cmds.c b/gdb/mi/mi-cmds.c > index fe30ac2e822..cd2ffa5fc37 100644 > --- a/gdb/mi/mi-cmds.c > +++ b/gdb/mi/mi-cmds.c > @@ -75,6 +75,12 @@ static struct mi_cmd mi_cmds[] = > &mi_suppress_notification.breakpoint), > DEF_MI_CMD_MI_1 ("catch-unload", mi_cmd_catch_unload, > &mi_suppress_notification.breakpoint), > + DEF_MI_CMD_MI_1 ("catch-throw", mi_cmd_catch_throw, > + &mi_suppress_notification.breakpoint), > + DEF_MI_CMD_MI_1 ("catch-rethrow", mi_cmd_catch_rethrow, > + &mi_suppress_notification.breakpoint), > + DEF_MI_CMD_MI_1 ("catch-catch", mi_cmd_catch_catch, > + &mi_suppress_notification.breakpoint), > DEF_MI_CMD_MI ("data-disassemble", mi_cmd_disassemble), > DEF_MI_CMD_MI ("data-evaluate-expression", mi_cmd_data_evaluate_expression), > DEF_MI_CMD_MI ("data-list-changed-registers", > diff --git a/gdb/mi/mi-cmds.h b/gdb/mi/mi-cmds.h > index 7b22ce78134..5a8e99bd33c 100644 > --- a/gdb/mi/mi-cmds.h > +++ b/gdb/mi/mi-cmds.h > @@ -44,6 +44,9 @@ extern mi_cmd_argv_ftype mi_cmd_catch_exception; > extern mi_cmd_argv_ftype mi_cmd_catch_handlers; > extern mi_cmd_argv_ftype mi_cmd_catch_load; > extern mi_cmd_argv_ftype mi_cmd_catch_unload; > +extern mi_cmd_argv_ftype mi_cmd_catch_throw; > +extern mi_cmd_argv_ftype mi_cmd_catch_rethrow; > +extern mi_cmd_argv_ftype mi_cmd_catch_catch; > extern mi_cmd_argv_ftype mi_cmd_disassemble; > extern mi_cmd_argv_ftype mi_cmd_data_evaluate_expression; > extern mi_cmd_argv_ftype mi_cmd_data_list_register_names; > diff --git a/gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.cc b/gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.cc > new file mode 100644 > index 00000000000..cacda4653a9 > --- /dev/null > +++ b/gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.cc > @@ -0,0 +1,73 @@ > +/* Copyright 2019 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 . */ > + > +class my_exception > +{ > +private: > + int m_value; > + > +public: > + my_exception (int v) > + : m_value (v) > + { > + /* Nothing. */ > + } > +}; > + > +void > +bar () > +{ > + my_exception ex (4); > + throw ex; /* Throw 1. */ > +} > + > +void > +foo () > +{ > + for (int i = 0; i < 2; ++i) > + { > + try > + { > + bar (); > + } > + catch (const my_exception &ex) /* Catch 1. */ > + { > + if (i == 1) > + throw; /* Throw 2. */ > + } > + } > +} > + > +int > +main () > +{ > + for (int i = 0; i < 2; ++i) > + { > + try > + { > + foo (); > + } > + catch (const my_exception &ex) /* Catch 2. */ > + { > + if (i == 1) > + return 1; /* Stop here. */ > + } > + } > + > + return 0; > +} > + > diff --git a/gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.exp b/gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.exp > new file mode 100644 > index 00000000000..b5dfbe68c1a > --- /dev/null > +++ b/gdb/testsuite/gdb.mi/mi-catch-cpp-exceptions.exp > @@ -0,0 +1,197 @@ > +# Copyright 2019 Free Software Foundation, Inc. > + > +# 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 . > + > +# Test the -catch-throw, -catch-rethrow, and -catch-catch MI commands. > + > +if { [skip_cplus_tests] } { continue } > + > +load_lib mi-support.exp > +set MIFLAGS "-i=mi" > + > +standard_testfile .cc > + > +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } { > + untested "failed to compile" > + return -1 > +} > + > +# Grab some line numbers we'll need. > +set catch_1_lineno [gdb_get_line_number "Catch 1"] > +set catch_2_lineno [gdb_get_line_number "Catch 2"] > +set throw_1_lineno [gdb_get_line_number "Throw 1"] > +set throw_2_lineno [gdb_get_line_number "Throw 2"] > +set main_lineno [gdb_get_line_number "Stop here"] > + > +# Restart this test, load the test binary and set a breakpoint in > +# main. > +proc restart_for_test {} { > + global srcdir subdir binfile srcfile > + global main_lineno > + > + if {[mi_gdb_start]} { > + continue > + } > + > + mi_delete_breakpoints > + mi_gdb_reinitialize_dir $srcdir/$subdir > + mi_gdb_load ${binfile} > + > + mi_runto main > + > + mi_create_breakpoint \ > + "$srcfile:${main_lineno}" "break before exiting program" \ > + -disp keep -func "main.*" \ > + -file ".*mi-catch-cpp-exceptions.cc" -line ${main_lineno} > +} > + > +# Issue an -exec-continue then wait for GDB to catch a C++ exception > +# event in FUNC on LINE. Use TESTNAME to make tests unique. > +proc continue_to_next_exception { func line testname } { > + global hex > + > + mi_send_resuming_command "exec-continue" \ > + "exec-continue" > + mi_expect_stop "exception-caught" ".*" ".*" ".*" ".*" \ > + {} "run until an exception is caught: $testname" > + mi_gdb_test "-stack-list-frames 1 1" \ > + "\\^done,stack=\\\[frame=\{level=\"1\",addr=\"$hex\",func=\"${func}\",.*,line=\"${line}\".*\}\\\]" \ > + "check previous frame: $testname" > +} > + > +# Issue an -exec-continue and stop at the breakpoint in main. > +proc continue_to_breakpoint_in_main {} { > + global main_lineno > + > + mi_send_resuming_command "exec-continue" "exec-continue to main" > + mi_expect_stop "breakpoint-hit" "main" ".*" ".*" "${main_lineno}" \ > + {.* disp="keep"} "run until breakpoint in main" > +} > + > +# TYPE is one of throw, rethrow, or catch. This proc creates a catch > +# point using -catch-TYPE. The optional string EXTRA is any extra > +# arguments to pass when setting up the catchpoint. > +proc setup_catchpoint {type {extra ""}} { > + global decimal > + mi_gdb_test "-catch-${type} ${extra}" \ > + "\\^done,bkpt=\{number=\"$decimal\".*what=\"exception ${type}\",catch-type=\"${type}\".*\}" \ > + "Setup -catch-${type}" > +} > + > +# Ensure that -catch-throw will catch only throws and nothing else. > +with_test_prefix "-catch-throw" { > + restart_for_test > + setup_catchpoint "throw" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 1" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 2" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 3" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 4" > + continue_to_breakpoint_in_main > +} > + > +# Ensure that -catch-rethrow catches only rethrows and nothing else. > +with_test_prefix "-catch-rethrow" { > + restart_for_test > + setup_catchpoint "rethrow" > + continue_to_next_exception "foo" "${throw_2_lineno}" "rethrow 1" > + continue_to_next_exception "foo" "${throw_2_lineno}" "rethrow 2" > + continue_to_breakpoint_in_main > +} > + > +# Ensure that -catch-catch catches only catch points, and nothing > +# else. > +with_test_prefix "-catch-catch" { > + restart_for_test > + setup_catchpoint "catch" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 1" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 2" > + continue_to_next_exception "main" "${catch_2_lineno}" "catch 3" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 4" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 5" > + continue_to_next_exception "main" "${catch_2_lineno}" "catch 6" > + continue_to_breakpoint_in_main > +} > + > +# Now check that all of the command with a regexp that doesn't match, > +# don't trigger. > +with_test_prefix "all with invalid regexp" { > + restart_for_test > + setup_catchpoint "throw" "-r blahblah" > + setup_catchpoint "rethrow" "-r woofwoof" > + setup_catchpoint "catch" "-r miowmiow" > + > + # Would like to use 'continue_to_breakpoint_in_main' here, if > + # there wasn't a bug that requires a use of kfail. > + > + mi_send_resuming_command "exec-continue" \ > + "exec-continue" > + set testname "run until breakpoint in main" > + gdb_expect { > + -re "could not find minimal symbol for typeinfo address.*$mi_gdb_prompt$" { > + kfail "gdb/24541" "${testname}" > + } > + -re "\\*stopped,reason=\"breakpoint-hit\".*func=\"main\".*line=\"${main_lineno}\".*$mi_gdb_prompt$" { > + pass "${testname}" > + } > + timeout { > + fail "${testname} (timeout)" > + } > + } > +} > + > +# Now check that all of the commands with a regexp that does match, > +# still trigger. > +with_test_prefix "all with valid regexp" { > + restart_for_test > + setup_catchpoint "throw" "-r my_ex" > + setup_catchpoint "rethrow" "-r _except" > + setup_catchpoint "catch" "-r my_exception" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 1" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 1" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 2" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 2" > + continue_to_next_exception "foo" "${throw_2_lineno}" "rethrow 1" > + continue_to_next_exception "main" "${catch_2_lineno}" "catch 3" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 3" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 4" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 4" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 5" > + continue_to_next_exception "foo" "${throw_2_lineno}" "rethrow 2" > + continue_to_next_exception "main" "${catch_2_lineno}" "catch 6" > + continue_to_breakpoint_in_main > +} > + > +# Check that the temporary switch works on its own. > +with_test_prefix "all with -t" { > + restart_for_test > + setup_catchpoint "throw" "-t" > + setup_catchpoint "rethrow" "-t" > + setup_catchpoint "catch" "-t" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 1" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 1" > + continue_to_next_exception "foo" "${throw_2_lineno}" "rethrow 1" > + continue_to_breakpoint_in_main > +} > + > +# Check that the temporary switch works when used with a regexp. > +restart_for_test > +with_test_prefix "all with -t and regexp" { > + setup_catchpoint "throw" "-t -r my_ex" > + setup_catchpoint "rethrow" "-t -r _except" > + setup_catchpoint "catch" "-t -r my_exception" > + continue_to_next_exception "bar" "${throw_1_lineno}" "throw 1" > + continue_to_next_exception "foo" "${catch_1_lineno}" "catch 1" > + continue_to_next_exception "foo" "${throw_2_lineno}" "rethrow 1" > + continue_to_breakpoint_in_main > +} > diff --git a/gdb/testsuite/lib/mi-support.exp b/gdb/testsuite/lib/mi-support.exp > index a58c4f6e119..8c2c7c84eda 100644 > --- a/gdb/testsuite/lib/mi-support.exp > +++ b/gdb/testsuite/lib/mi-support.exp > @@ -1221,10 +1221,15 @@ proc mi_expect_stop { reason func args file line extra test } { > set args "\\\[$args\\\]" > > set bn "" > + set ebn "" > if { $reason == "breakpoint-hit" } { > set bn {bkptno="[0-9]+",} > } elseif { $reason == "solib-event" } { > set bn ".*" > + } elseif { $reason == "exception-caught" } { > + set ebn {bkptno="[0-9]+",} > + set bn ".*" > + set reason "breakpoint-hit" > } > > set r "" > @@ -1235,9 +1240,9 @@ proc mi_expect_stop { reason func args file line extra test } { > > set a $after_reason > > - verbose -log "mi_expect_stop: expecting: \\*stopped,${r}${a}${bn}frame=\{addr=\"$hex\",func=\"$func\",args=$args,(?:file=\"$any$file\",fullname=\"${fullname_syntax}$file\",line=\"$line\",arch=\"$any\"|from=\"$file\")\}$after_stopped,thread-id=\"$decimal\",stopped-threads=$any\r\n($thread_selected_re|$breakpoint_re)*$prompt_re" > + verbose -log "mi_expect_stop: expecting: \\*stopped,${ebn}${r}${a}${bn}frame=\{addr=\"$hex\",func=\"$func\",args=$args,(?:file=\"$any$file\",fullname=\"${fullname_syntax}$file\",line=\"$line\",arch=\"$any\"|from=\"$file\")\}$after_stopped,thread-id=\"$decimal\",stopped-threads=$any\r\n($thread_selected_re|$breakpoint_re)*$prompt_re" > gdb_expect { > - -re "\\*stopped,${r}${a}${bn}frame=\{addr=\"$hex\",func=\"$func\",args=$args,(?:file=\"$any$file\",fullname=\"${fullname_syntax}$file\",line=\"($line)\",arch=\"$any\"|from=\"$file\")\}$after_stopped,thread-id=\"$decimal\",stopped-threads=$any\r\n($thread_selected_re|$breakpoint_re)*$prompt_re" { > + -re "\\*stopped,${ebn}${r}${a}${bn}frame=\{addr=\"$hex\",func=\"$func\",args=$args,(?:file=\"$any$file\",fullname=\"${fullname_syntax}$file\",line=\"($line)\",arch=\"$any\"|from=\"$file\")\}$after_stopped,thread-id=\"$decimal\",stopped-threads=$any\r\n($thread_selected_re|$breakpoint_re)*$prompt_re" { > pass "$test" > if {[array names expect_out "2,string"] != ""} { > return $expect_out(2,string) > @@ -1245,7 +1250,7 @@ proc mi_expect_stop { reason func args file line extra test } { > # No debug info available but $file does match. > return 0 > } > - -re "\\*stopped,${r}${a}${bn}frame=\{addr=\"$hex\",func=\"$any\",args=\[\\\[\{\]$any\[\\\]\}\],file=\"$any\",fullname=\"${fullname_syntax}$any\",line=\"\[0-9\]*\",arch=\"$any\"\}$after_stopped,thread-id=\"$decimal\",stopped-threads=$any\r\n($thread_selected_re|$breakpoint_re)*$prompt_re" { > + -re "\\*stopped,${ebn}${r}${a}${bn}frame=\{addr=\"$hex\",func=\"$any\",args=\[\\\[\{\]$any\[\\\]\}\],file=\"$any\",fullname=\"${fullname_syntax}$any\",line=\"\[0-9\]*\",arch=\"$any\"\}$after_stopped,thread-id=\"$decimal\",stopped-threads=$any\r\n($thread_selected_re|$breakpoint_re)*$prompt_re" { > verbose -log "got $expect_out(buffer)" > fail "$test (stopped at wrong place)" > return -1 > -- > 2.14.5 >