From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2126) id 34F6C3858037; Tue, 18 Jan 2022 17:50:12 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 34F6C3858037 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Tom Tromey To: gdb-cvs@sourceware.org Subject: [binutils-gdb] Move "catch fork" to a new file X-Act-Checkin: binutils-gdb X-Git-Author: Tom Tromey X-Git-Refname: refs/heads/master X-Git-Oldrev: 59505f2cec80bfd0b721a53104dbbf7f300127b7 X-Git-Newrev: 064f3c6a01ba890369081a9f2c9cb1d62f8b9c34 Message-Id: <20220118175012.34F6C3858037@sourceware.org> Date: Tue, 18 Jan 2022 17:50:12 +0000 (GMT) X-BeenThere: gdb-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 18 Jan 2022 17:50:12 -0000 https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D064f3c6a01ba= 890369081a9f2c9cb1d62f8b9c34 commit 064f3c6a01ba890369081a9f2c9cb1d62f8b9c34 Author: Tom Tromey Date: Wed Jan 12 16:03:33 2022 -0700 Move "catch fork" to a new file =20 The "catch fork" code is reasonably self-contained, and so this patch moves it out of breakpoint.c (the second largest source file in gdb) and into a new file, break-catch-fork.c. Diff: --- gdb/Makefile.in | 1 + gdb/break-catch-fork.c | 286 +++++++++++++++++++++++++++++++++++++++++++++= ++++ gdb/breakpoint.c | 243 ----------------------------------------- 3 files changed, 287 insertions(+), 243 deletions(-) diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 2d9b2a76491..6ae511d0e1d 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -999,6 +999,7 @@ COMMON_SFILES =3D \ bfd-target.c \ block.c \ blockframe.c \ + break-catch-fork.c \ break-catch-sig.c \ break-catch-syscall.c \ break-catch-throw.c \ diff --git a/gdb/break-catch-fork.c b/gdb/break-catch-fork.c new file mode 100644 index 00000000000..af44a9fe76e --- /dev/null +++ b/gdb/break-catch-fork.c @@ -0,0 +1,286 @@ +/* Everything about vfork catchpoints, for GDB. + + Copyright (C) 1986-2022 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 . = */ + +#include "defs.h" + +#include "annotate.h" +#include "arch-utils.h" +#include "breakpoint.h" +#include "cli/cli-decode.h" +#include "inferior.h" +#include "mi/mi-common.h" +#include "target.h" +#include "valprint.h" + +/* An instance of this type is used to represent a fork or vfork + catchpoint. A breakpoint is really of this type iff its ops pointer po= ints + to CATCH_FORK_BREAKPOINT_OPS. */ + +struct fork_catchpoint : public breakpoint +{ + /* True if the breakpoint is for vfork, false for fork. */ + bool is_vfork; + + /* Process id of a child process whose forking triggered this + catchpoint. This field is only valid immediately after this + catchpoint has triggered. */ + ptid_t forked_inferior_pid; +}; + +/* Implement the "insert" breakpoint_ops method for fork + catchpoints. */ + +static int +insert_catch_fork (struct bp_location *bl) +{ + struct fork_catchpoint *c =3D (struct fork_catchpoint *) bl->owner; + + if (c->is_vfork) + return target_insert_vfork_catchpoint (inferior_ptid.pid ()); + else + return target_insert_fork_catchpoint (inferior_ptid.pid ()); +} + +/* Implement the "remove" breakpoint_ops method for fork + catchpoints. */ + +static int +remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason) +{ + struct fork_catchpoint *c =3D (struct fork_catchpoint *) bl->owner; + + if (c->is_vfork) + return target_remove_vfork_catchpoint (inferior_ptid.pid ()); + else + return target_remove_fork_catchpoint (inferior_ptid.pid ()); +} + +/* Implement the "breakpoint_hit" breakpoint_ops method for fork + catchpoints. */ + +static int +breakpoint_hit_catch_fork (const struct bp_location *bl, + const address_space *aspace, CORE_ADDR bp_addr, + const target_waitstatus &ws) +{ + struct fork_catchpoint *c =3D (struct fork_catchpoint *) bl->owner; + + if (ws.kind () !=3D (c->is_vfork + ? TARGET_WAITKIND_VFORKED + : TARGET_WAITKIND_FORKED)) + return 0; + + c->forked_inferior_pid =3D ws.child_ptid (); + return 1; +} + +/* Implement the "print_it" breakpoint_ops method for fork + catchpoints. */ + +static enum print_stop_action +print_it_catch_fork (bpstat *bs) +{ + struct ui_out *uiout =3D current_uiout; + struct breakpoint *b =3D bs->breakpoint_at; + struct fork_catchpoint *c =3D (struct fork_catchpoint *) bs->breakpoint_= at; + + annotate_catchpoint (b->number); + maybe_print_thread_hit_breakpoint (uiout); + if (b->disposition =3D=3D disp_del) + uiout->text ("Temporary catchpoint "); + else + uiout->text ("Catchpoint "); + if (uiout->is_mi_like_p ()) + { + uiout->field_string ("reason", + async_reason_lookup (c->is_vfork + ? EXEC_ASYNC_VFORK + : EXEC_ASYNC_FORK)); + uiout->field_string ("disp", bpdisp_text (b->disposition)); + } + uiout->field_signed ("bkptno", b->number); + if (c->is_vfork) + uiout->text (" (vforked process "); + else + uiout->text (" (forked process "); + uiout->field_signed ("newpid", c->forked_inferior_pid.pid ()); + uiout->text ("), "); + return PRINT_SRC_AND_LOC; +} + +/* Implement the "print_one" breakpoint_ops method for fork + catchpoints. */ + +static void +print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc) +{ + struct fork_catchpoint *c =3D (struct fork_catchpoint *) b; + struct value_print_options opts; + struct ui_out *uiout =3D current_uiout; + + get_user_print_options (&opts); + + /* Field 4, the address, is omitted (which makes the columns not + line up too nicely with the headers, but the effect is relatively + readable). */ + if (opts.addressprint) + uiout->field_skip ("addr"); + annotate_field (5); + const char *name =3D c->is_vfork ? "vfork" : "fork"; + uiout->text (name); + if (c->forked_inferior_pid !=3D null_ptid) + { + uiout->text (", process "); + uiout->field_signed ("what", c->forked_inferior_pid.pid ()); + uiout->spaces (1); + } + + if (uiout->is_mi_like_p ()) + uiout->field_string ("catch-type", name); +} + +/* Implement the "print_mention" breakpoint_ops method for fork + catchpoints. */ + +static void +print_mention_catch_fork (struct breakpoint *b) +{ + struct fork_catchpoint *c =3D (struct fork_catchpoint *) b; + printf_filtered (_("Catchpoint %d (%s)"), c->number, + c->is_vfork ? "vfork" : "fork"); +} + +/* Implement the "print_recreate" breakpoint_ops method for fork + catchpoints. */ + +static void +print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp) +{ + struct fork_catchpoint *c =3D (struct fork_catchpoint *) b; + fprintf_unfiltered (fp, "catch %s", + c->is_vfork ? "vfork" : "fork"); + print_recreate_thread (b, fp); +} + +/* The breakpoint_ops structure to be used in fork catchpoints. */ + +static struct breakpoint_ops catch_fork_breakpoint_ops; + +static void +create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch, + bool temp, const char *cond_string, + bool is_vfork) +{ + std::unique_ptr c (new fork_catchpoint ()); + + init_catchpoint (c.get (), gdbarch, temp, cond_string, + &catch_fork_breakpoint_ops); + c->is_vfork =3D is_vfork; + c->forked_inferior_pid =3D null_ptid; + + install_breakpoint (0, std::move (c), 1); +} + +typedef enum +{ + catch_fork_temporary, catch_vfork_temporary, + catch_fork_permanent, catch_vfork_permanent +} +catch_fork_kind; + +static void +catch_fork_command_1 (const char *arg, int from_tty, + struct cmd_list_element *command) +{ + struct gdbarch *gdbarch =3D get_current_arch (); + const char *cond_string =3D NULL; + catch_fork_kind fork_kind; + + fork_kind =3D (catch_fork_kind) (uintptr_t) command->context (); + bool temp =3D (fork_kind =3D=3D catch_fork_temporary + || fork_kind =3D=3D catch_vfork_temporary); + + if (!arg) + arg =3D ""; + arg =3D skip_spaces (arg); + + /* The allowed syntax is: + catch [v]fork + catch [v]fork if + + First, check if there's an if clause. */ + cond_string =3D ep_parse_optional_if_clause (&arg); + + if ((*arg !=3D '\0') && !isspace (*arg)) + error (_("Junk at end of arguments.")); + + /* If this target supports it, create a fork or vfork catchpoint + and enable reporting of such events. */ + switch (fork_kind) + { + case catch_fork_temporary: + case catch_fork_permanent: + create_fork_vfork_event_catchpoint (gdbarch, temp, cond_string, fals= e); + break; + case catch_vfork_temporary: + case catch_vfork_permanent: + create_fork_vfork_event_catchpoint (gdbarch, temp, cond_string, true= ); + break; + default: + error (_("unsupported or unknown fork kind; cannot catch it")); + break; + } +} + +static void +initialize_ops () +{ + struct breakpoint_ops *ops; + + initialize_breakpoint_ops (); + + /* Fork catchpoints. */ + ops =3D &catch_fork_breakpoint_ops; + *ops =3D base_breakpoint_ops; + ops->insert_location =3D insert_catch_fork; + ops->remove_location =3D remove_catch_fork; + ops->breakpoint_hit =3D breakpoint_hit_catch_fork; + ops->print_it =3D print_it_catch_fork; + ops->print_one =3D print_one_catch_fork; + ops->print_mention =3D print_mention_catch_fork; + ops->print_recreate =3D print_recreate_catch_fork; +} + +void _initialize_break_catch_fork (); +void +_initialize_break_catch_fork () +{ + initialize_ops (); + + add_catch_command ("fork", _("Catch calls to fork."), + catch_fork_command_1, + NULL, + (void *) (uintptr_t) catch_fork_permanent, + (void *) (uintptr_t) catch_fork_temporary); + add_catch_command ("vfork", _("Catch calls to vfork."), + catch_fork_command_1, + NULL, + (void *) (uintptr_t) catch_vfork_permanent, + (void *) (uintptr_t) catch_vfork_temporary); +} diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index ede8b43dcab..bfda5d70d9e 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -7722,162 +7722,6 @@ disable_breakpoints_in_freed_objfile (struct objfil= e *objfile) } } =20 -/* FORK & VFORK catchpoints. */ - -/* An instance of this type is used to represent a fork or vfork - catchpoint. A breakpoint is really of this type iff its ops pointer po= ints - to CATCH_FORK_BREAKPOINT_OPS. */ - -struct fork_catchpoint : public breakpoint -{ - /* True if the breakpoint is for vfork, false for fork. */ - bool is_vfork; - - /* Process id of a child process whose forking triggered this - catchpoint. This field is only valid immediately after this - catchpoint has triggered. */ - ptid_t forked_inferior_pid; -}; - -/* Implement the "insert" breakpoint_ops method for fork - catchpoints. */ - -static int -insert_catch_fork (struct bp_location *bl) -{ - struct fork_catchpoint *c =3D (struct fork_catchpoint *) bl->owner; - - if (c->is_vfork) - return target_insert_vfork_catchpoint (inferior_ptid.pid ()); - else - return target_insert_fork_catchpoint (inferior_ptid.pid ()); -} - -/* Implement the "remove" breakpoint_ops method for fork - catchpoints. */ - -static int -remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason) -{ - struct fork_catchpoint *c =3D (struct fork_catchpoint *) bl->owner; - - if (c->is_vfork) - return target_remove_vfork_catchpoint (inferior_ptid.pid ()); - else - return target_remove_fork_catchpoint (inferior_ptid.pid ()); -} - -/* Implement the "breakpoint_hit" breakpoint_ops method for fork - catchpoints. */ - -static int -breakpoint_hit_catch_fork (const struct bp_location *bl, - const address_space *aspace, CORE_ADDR bp_addr, - const target_waitstatus &ws) -{ - struct fork_catchpoint *c =3D (struct fork_catchpoint *) bl->owner; - - if (ws.kind () !=3D (c->is_vfork - ? TARGET_WAITKIND_VFORKED - : TARGET_WAITKIND_FORKED)) - return 0; - - c->forked_inferior_pid =3D ws.child_ptid (); - return 1; -} - -/* Implement the "print_it" breakpoint_ops method for fork - catchpoints. */ - -static enum print_stop_action -print_it_catch_fork (bpstat *bs) -{ - struct ui_out *uiout =3D current_uiout; - struct breakpoint *b =3D bs->breakpoint_at; - struct fork_catchpoint *c =3D (struct fork_catchpoint *) bs->breakpoint_= at; - - annotate_catchpoint (b->number); - maybe_print_thread_hit_breakpoint (uiout); - if (b->disposition =3D=3D disp_del) - uiout->text ("Temporary catchpoint "); - else - uiout->text ("Catchpoint "); - if (uiout->is_mi_like_p ()) - { - uiout->field_string ("reason", - async_reason_lookup (c->is_vfork - ? EXEC_ASYNC_VFORK - : EXEC_ASYNC_FORK)); - uiout->field_string ("disp", bpdisp_text (b->disposition)); - } - uiout->field_signed ("bkptno", b->number); - if (c->is_vfork) - uiout->text (" (vforked process "); - else - uiout->text (" (forked process "); - uiout->field_signed ("newpid", c->forked_inferior_pid.pid ()); - uiout->text ("), "); - return PRINT_SRC_AND_LOC; -} - -/* Implement the "print_one" breakpoint_ops method for fork - catchpoints. */ - -static void -print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc) -{ - struct fork_catchpoint *c =3D (struct fork_catchpoint *) b; - struct value_print_options opts; - struct ui_out *uiout =3D current_uiout; - - get_user_print_options (&opts); - - /* Field 4, the address, is omitted (which makes the columns not - line up too nicely with the headers, but the effect is relatively - readable). */ - if (opts.addressprint) - uiout->field_skip ("addr"); - annotate_field (5); - const char *name =3D c->is_vfork ? "vfork" : "fork"; - uiout->text (name); - if (c->forked_inferior_pid !=3D null_ptid) - { - uiout->text (", process "); - uiout->field_signed ("what", c->forked_inferior_pid.pid ()); - uiout->spaces (1); - } - - if (uiout->is_mi_like_p ()) - uiout->field_string ("catch-type", name); -} - -/* Implement the "print_mention" breakpoint_ops method for fork - catchpoints. */ - -static void -print_mention_catch_fork (struct breakpoint *b) -{ - struct fork_catchpoint *c =3D (struct fork_catchpoint *) b; - printf_filtered (_("Catchpoint %d (%s)"), c->number, - c->is_vfork ? "vfork" : "fork"); -} - -/* Implement the "print_recreate" breakpoint_ops method for fork - catchpoints. */ - -static void -print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp) -{ - struct fork_catchpoint *c =3D (struct fork_catchpoint *) b; - fprintf_unfiltered (fp, "catch %s", - c->is_vfork ? "vfork" : "fork"); - print_recreate_thread (b, fp); -} - -/* The breakpoint_ops structure to be used in fork catchpoints. */ - -static struct breakpoint_ops catch_fork_breakpoint_ops; - /* An instance of this type is used to represent an solib catchpoint. A breakpoint is really of this type iff its ops pointer points to CATCH_SOLIB_BREAKPOINT_OPS. */ @@ -8142,21 +7986,6 @@ install_breakpoint (int internal, std::unique_ptr &&arg, int update_ update_global_location_list (UGLL_MAY_INSERT); } =20 -static void -create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch, - bool temp, const char *cond_string, - bool is_vfork) -{ - std::unique_ptr c (new fork_catchpoint ()); - - init_catchpoint (c.get (), gdbarch, temp, cond_string, - &catch_fork_breakpoint_ops); - c->is_vfork =3D is_vfork; - c->forked_inferior_pid =3D null_ptid; - - install_breakpoint (0, std::move (c), 1); -} - /* Exec catchpoints. */ =20 /* An instance of this type is used to represent an exec catchpoint. @@ -11163,57 +10992,6 @@ ep_parse_optional_if_clause (const char **arg) /* Commands to deal with catching events, such as signals, exceptions, process start/exit, etc. */ =20 -typedef enum -{ - catch_fork_temporary, catch_vfork_temporary, - catch_fork_permanent, catch_vfork_permanent -} -catch_fork_kind; - -static void -catch_fork_command_1 (const char *arg, int from_tty, - struct cmd_list_element *command) -{ - struct gdbarch *gdbarch =3D get_current_arch (); - const char *cond_string =3D NULL; - catch_fork_kind fork_kind; - - fork_kind =3D (catch_fork_kind) (uintptr_t) command->context (); - bool temp =3D (fork_kind =3D=3D catch_fork_temporary - || fork_kind =3D=3D catch_vfork_temporary); - - if (!arg) - arg =3D ""; - arg =3D skip_spaces (arg); - - /* The allowed syntax is: - catch [v]fork - catch [v]fork if - - First, check if there's an if clause. */ - cond_string =3D ep_parse_optional_if_clause (&arg); - - if ((*arg !=3D '\0') && !isspace (*arg)) - error (_("Junk at end of arguments.")); - - /* If this target supports it, create a fork or vfork catchpoint - and enable reporting of such events. */ - switch (fork_kind) - { - case catch_fork_temporary: - case catch_fork_permanent: - create_fork_vfork_event_catchpoint (gdbarch, temp, cond_string, fals= e); - break; - case catch_vfork_temporary: - case catch_vfork_permanent: - create_fork_vfork_event_catchpoint (gdbarch, temp, cond_string, true= ); - break; - default: - error (_("unsupported or unknown fork kind; cannot catch it")); - break; - } -} - static void catch_exec_command_1 (const char *arg, int from_tty, struct cmd_list_element *command) @@ -15264,17 +15042,6 @@ initialize_breakpoint_ops (void) ops->create_breakpoints_sal =3D strace_marker_create_breakpoints_sal; ops->decode_location =3D strace_marker_decode_location; =20 - /* Fork catchpoints. */ - ops =3D &catch_fork_breakpoint_ops; - *ops =3D base_breakpoint_ops; - ops->insert_location =3D insert_catch_fork; - ops->remove_location =3D remove_catch_fork; - ops->breakpoint_hit =3D breakpoint_hit_catch_fork; - ops->print_it =3D print_it_catch_fork; - ops->print_one =3D print_one_catch_fork; - ops->print_mention =3D print_mention_catch_fork; - ops->print_recreate =3D print_recreate_catch_fork; - /* Exec catchpoints. */ ops =3D &catch_exec_breakpoint_ops; *ops =3D base_breakpoint_ops; @@ -15590,16 +15357,6 @@ Set temporary catchpoints to catch events."), &tcatch_cmdlist, 0/*allow-unknown*/, &cmdlist); =20 - add_catch_command ("fork", _("Catch calls to fork."), - catch_fork_command_1, - NULL, - (void *) (uintptr_t) catch_fork_permanent, - (void *) (uintptr_t) catch_fork_temporary); - add_catch_command ("vfork", _("Catch calls to vfork."), - catch_fork_command_1, - NULL, - (void *) (uintptr_t) catch_vfork_permanent, - (void *) (uintptr_t) catch_vfork_temporary); add_catch_command ("exec", _("Catch calls to exec."), catch_exec_command_1, NULL,