gdb/break-catch-load.c - binutils-gdb - Git at Google

 /* Everything about load/unload catchpoints, for GDB.

    Copyright (C) 1986-2024 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 "annotate.h"
 #include "arch-utils.h"
 #include "breakpoint.h"
 #include "cli/cli-decode.h"
 #include "mi/mi-common.h"
 #include "progspace.h"
 #include "solist.h"
 #include "target.h"
 #include "valprint.h"

 /* 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.  */

 struct solib_catchpoint : public catchpoint
 {
   solib_catchpoint (struct gdbarch *gdbarch, bool temp,
 		    const char *cond_string,
 		    bool is_load_, const char *arg)
     : catchpoint (gdbarch, temp, cond_string),
       is_load (is_load_),
       regex (arg == nullptr ? nullptr : make_unique_xstrdup (arg)),
       compiled (arg == nullptr
 		? nullptr
 		: new compiled_regex (arg, REG_NOSUB, _("Invalid regexp")))
   {
   }

   int insert_location (struct bp_location *) override;
   int remove_location (struct bp_location *,
 		       enum remove_bp_reason reason) override;
   int breakpoint_hit (const struct bp_location *bl,
 		      const address_space *aspace,
 		      CORE_ADDR bp_addr,
 		      const target_waitstatus &ws) override;
   void check_status (struct bpstat *bs) override;
   enum print_stop_action print_it (const bpstat *bs) const override;
   bool print_one (const bp_location **) const override;
   void print_mention () const override;
   void print_recreate (struct ui_file *fp) const override;

   /* True for "catch load", false for "catch unload".  */
   bool is_load;

   /* Regular expression to match, if any.  COMPILED is only valid when
      REGEX is non-NULL.  */
   gdb::unique_xmalloc_ptr<char> regex;
   std::unique_ptr<compiled_regex> compiled;
 };

 int
 solib_catchpoint::insert_location (struct bp_location *ignore)
 {
   return 0;
 }

 int
 solib_catchpoint::remove_location (struct bp_location *ignore,
 				   enum remove_bp_reason reason)
 {
   return 0;
 }

 int
 solib_catchpoint::breakpoint_hit (const struct bp_location *bl,
 				  const address_space *aspace,
 				  CORE_ADDR bp_addr,
 				  const target_waitstatus &ws)
 {
   if (ws.kind () == TARGET_WAITKIND_LOADED)
     return 1;

   for (breakpoint &other : all_breakpoints ())
     {
       if (&other == bl->owner)
 	continue;

       if (other.type != bp_shlib_event)
 	continue;

       if (pspace != NULL && other.pspace != pspace)
 	continue;

       for (bp_location &other_bl : other.locations ())
 	{
 	  if (other.breakpoint_hit (&other_bl, aspace, bp_addr, ws))
 	    return 1;
 	}
     }

   return 0;
 }

 void
 solib_catchpoint::check_status (struct bpstat *bs)
 {
   if (is_load)
     {
       for (solib *iter : current_program_space->added_solibs)
 	{
 	  if (!regex
 	      || compiled->exec (iter->so_name.c_str (), 0, nullptr, 0) == 0)
 	    return;
 	}
     }
   else
     {
       for (const std::string &iter : current_program_space->deleted_solibs)
 	{
 	  if (!regex
 	      || compiled->exec (iter.c_str (), 0, NULL, 0) == 0)
 	    return;
 	}
     }

   bs->stop = false;
   bs->print_it = print_it_noop;
 }

 enum print_stop_action
 solib_catchpoint::print_it (const bpstat *bs) const
 {
   struct ui_out *uiout = current_uiout;

   annotate_catchpoint (this->number);
   maybe_print_thread_hit_breakpoint (uiout);
   if (this->disposition == disp_del)
     uiout->text ("Temporary catchpoint ");
   else
     uiout->text ("Catchpoint ");
   uiout->field_signed ("bkptno", this->number);
   uiout->text ("\n");
   if (uiout->is_mi_like_p ())
     uiout->field_string ("disp", bpdisp_text (this->disposition));
   print_solib_event (true);
   return PRINT_SRC_AND_LOC;
 }

 bool
 solib_catchpoint::print_one (const bp_location **locs) const
 {
   struct value_print_options opts;
   struct ui_out *uiout = 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)
     {
       annotate_field (4);
       uiout->field_skip ("addr");
     }

   std::string msg;
   annotate_field (5);
   if (is_load)
     {
       if (regex)
 	msg = string_printf (_("load of library matching %s"),
 			     regex.get ());
       else
 	msg = _("load of library");
     }
   else
     {
       if (regex)
 	msg = string_printf (_("unload of library matching %s"),
 			     regex.get ());
       else
 	msg = _("unload of library");
     }
   uiout->field_string ("what", msg);

   if (uiout->is_mi_like_p ())
     uiout->field_string ("catch-type", is_load ? "load" : "unload");

   return true;
 }

 void
 solib_catchpoint::print_mention () const
 {
   gdb_printf (_("Catchpoint %d (%s)"), number,
 	      is_load ? "load" : "unload");
 }

 void
 solib_catchpoint::print_recreate (struct ui_file *fp) const
 {
   gdb_printf (fp, "%s %s",
 	      disposition == disp_del ? "tcatch" : "catch",
 	      is_load ? "load" : "unload");
   if (regex)
     gdb_printf (fp, " %s", regex.get ());
   gdb_printf (fp, "\n");
 }

 /* See breakpoint.h.  */

 void
 add_solib_catchpoint (const char *arg, bool is_load, bool is_temp, bool enabled)
 {
   struct gdbarch *gdbarch = get_current_arch ();

   if (!arg)
     arg = "";
   arg = skip_spaces (arg);
   if (*arg == '\0')
     arg = nullptr;

   auto c = std::make_unique<solib_catchpoint> (gdbarch, is_temp, nullptr,
 					       is_load, arg);

   c->enable_state = enabled ? bp_enabled : bp_disabled;

   install_breakpoint (0, std::move (c), 1);
 }

 /* A helper function that does all the work for "catch load" and
    "catch unload".  */

 static void
 catch_load_or_unload (const char *arg, int from_tty, int is_load,
 		      struct cmd_list_element *command)
 {
   const int enabled = 1;
   bool temp = command->context () == CATCH_TEMPORARY;

   add_solib_catchpoint (arg, is_load, temp, enabled);
 }

 static void
 catch_load_command_1 (const char *arg, int from_tty,
 		      struct cmd_list_element *command)
 {
   catch_load_or_unload (arg, from_tty, 1, command);
 }

 static void
 catch_unload_command_1 (const char *arg, int from_tty,
 			struct cmd_list_element *command)
 {
   catch_load_or_unload (arg, from_tty, 0, command);
 }

 void _initialize_break_catch_load ();
 void
 _initialize_break_catch_load ()
 {
   add_catch_command ("load", _("Catch loads of shared libraries.\n\
 Usage: catch load [REGEX]\n\
 If REGEX is given, only stop for libraries matching the regular expression."),
 		     catch_load_command_1,
 		     NULL,
 		     CATCH_PERMANENT,
 		     CATCH_TEMPORARY);
   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
 Usage: catch unload [REGEX]\n\
 If REGEX is given, only stop for libraries matching the regular expression."),
 		     catch_unload_command_1,
 		     NULL,
 		     CATCH_PERMANENT,
 		     CATCH_TEMPORARY);
 }
	/* Everything about load/unload catchpoints, for GDB.

	Copyright (C) 1986-2024 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 "annotate.h"
	#include "arch-utils.h"
	#include "breakpoint.h"
	#include "cli/cli-decode.h"
	#include "mi/mi-common.h"
	#include "progspace.h"
	#include "solist.h"
	#include "target.h"
	#include "valprint.h"

	/* 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. */

	struct solib_catchpoint : public catchpoint
	{
	solib_catchpoint (struct gdbarch *gdbarch, bool temp,
	const char *cond_string,
	bool is_load_, const char *arg)
	: catchpoint (gdbarch, temp, cond_string),
	is_load (is_load_),
	regex (arg == nullptr ? nullptr : make_unique_xstrdup (arg)),
	compiled (arg == nullptr
	? nullptr
	: new compiled_regex (arg, REG_NOSUB, _("Invalid regexp")))
	{
	}

	int insert_location (struct bp_location *) override;
	int remove_location (struct bp_location *,
	enum remove_bp_reason reason) override;
	int breakpoint_hit (const struct bp_location *bl,
	const address_space *aspace,
	CORE_ADDR bp_addr,
	const target_waitstatus &ws) override;
	void check_status (struct bpstat *bs) override;
	enum print_stop_action print_it (const bpstat *bs) const override;
	bool print_one (const bp_location **) const override;
	void print_mention () const override;
	void print_recreate (struct ui_file *fp) const override;

	/* True for "catch load", false for "catch unload". */
	bool is_load;

	/* Regular expression to match, if any. COMPILED is only valid when
	REGEX is non-NULL. */
	gdb::unique_xmalloc_ptr<char> regex;
	std::unique_ptr<compiled_regex> compiled;
	};

	int
	solib_catchpoint::insert_location (struct bp_location *ignore)
	{
	return 0;
	}

	int
	solib_catchpoint::remove_location (struct bp_location *ignore,
	enum remove_bp_reason reason)
	{
	return 0;
	}

	int
	solib_catchpoint::breakpoint_hit (const struct bp_location *bl,
	const address_space *aspace,
	CORE_ADDR bp_addr,
	const target_waitstatus &ws)
	{
	if (ws.kind () == TARGET_WAITKIND_LOADED)
	return 1;

	for (breakpoint &other : all_breakpoints ())
	{
	if (&other == bl->owner)
	continue;

	if (other.type != bp_shlib_event)
	continue;

	if (pspace != NULL && other.pspace != pspace)
	continue;

	for (bp_location &other_bl : other.locations ())
	{
	if (other.breakpoint_hit (&other_bl, aspace, bp_addr, ws))
	return 1;
	}
	}

	return 0;
	}

	void
	solib_catchpoint::check_status (struct bpstat *bs)
	{
	if (is_load)
	{
	for (solib *iter : current_program_space->added_solibs)
	{
	if (!regex
	\|\| compiled->exec (iter->so_name.c_str (), 0, nullptr, 0) == 0)
	return;
	}
	}
	else
	{
	for (const std::string &iter : current_program_space->deleted_solibs)
	{
	if (!regex
	\|\| compiled->exec (iter.c_str (), 0, NULL, 0) == 0)
	return;
	}
	}

	bs->stop = false;
	bs->print_it = print_it_noop;
	}

	enum print_stop_action
	solib_catchpoint::print_it (const bpstat *bs) const
	{
	struct ui_out *uiout = current_uiout;

	annotate_catchpoint (this->number);
	maybe_print_thread_hit_breakpoint (uiout);
	if (this->disposition == disp_del)
	uiout->text ("Temporary catchpoint ");
	else
	uiout->text ("Catchpoint ");
	uiout->field_signed ("bkptno", this->number);
	uiout->text ("\n");
	if (uiout->is_mi_like_p ())
	uiout->field_string ("disp", bpdisp_text (this->disposition));
	print_solib_event (true);
	return PRINT_SRC_AND_LOC;
	}

	bool
	solib_catchpoint::print_one (const bp_location **locs) const
	{
	struct value_print_options opts;
	struct ui_out *uiout = 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)
	{
	annotate_field (4);
	uiout->field_skip ("addr");
	}

	std::string msg;
	annotate_field (5);
	if (is_load)
	{
	if (regex)
	msg = string_printf (_("load of library matching %s"),
	regex.get ());
	else
	msg = _("load of library");
	}
	else
	{
	if (regex)
	msg = string_printf (_("unload of library matching %s"),
	regex.get ());
	else
	msg = _("unload of library");
	}
	uiout->field_string ("what", msg);

	if (uiout->is_mi_like_p ())
	uiout->field_string ("catch-type", is_load ? "load" : "unload");

	return true;
	}

	void
	solib_catchpoint::print_mention () const
	{
	gdb_printf (_("Catchpoint %d (%s)"), number,
	is_load ? "load" : "unload");
	}

	void
	solib_catchpoint::print_recreate (struct ui_file *fp) const
	{
	gdb_printf (fp, "%s %s",
	disposition == disp_del ? "tcatch" : "catch",
	is_load ? "load" : "unload");
	if (regex)
	gdb_printf (fp, " %s", regex.get ());
	gdb_printf (fp, "\n");
	}

	/* See breakpoint.h. */

	void
	add_solib_catchpoint (const char *arg, bool is_load, bool is_temp, bool enabled)
	{
	struct gdbarch *gdbarch = get_current_arch ();

	if (!arg)
	arg = "";
	arg = skip_spaces (arg);
	if (*arg == '\0')
	arg = nullptr;

	auto c = std::make_unique<solib_catchpoint> (gdbarch, is_temp, nullptr,
	is_load, arg);

	c->enable_state = enabled ? bp_enabled : bp_disabled;

	install_breakpoint (0, std::move (c), 1);
	}

	/* A helper function that does all the work for "catch load" and
	"catch unload". */

	static void
	catch_load_or_unload (const char *arg, int from_tty, int is_load,
	struct cmd_list_element *command)
	{
	const int enabled = 1;
	bool temp = command->context () == CATCH_TEMPORARY;

	add_solib_catchpoint (arg, is_load, temp, enabled);
	}

	static void
	catch_load_command_1 (const char *arg, int from_tty,
	struct cmd_list_element *command)
	{
	catch_load_or_unload (arg, from_tty, 1, command);
	}

	static void
	catch_unload_command_1 (const char *arg, int from_tty,
	struct cmd_list_element *command)
	{
	catch_load_or_unload (arg, from_tty, 0, command);
	}

	void _initialize_break_catch_load ();
	void
	_initialize_break_catch_load ()
	{
	add_catch_command ("load", _("Catch loads of shared libraries.\n\
	Usage: catch load [REGEX]\n\
	If REGEX is given, only stop for libraries matching the regular expression."),
	catch_load_command_1,
	NULL,
	CATCH_PERMANENT,
	CATCH_TEMPORARY);
	add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
	Usage: catch unload [REGEX]\n\
	If REGEX is given, only stop for libraries matching the regular expression."),
	catch_unload_command_1,
	NULL,
	CATCH_PERMANENT,
	CATCH_TEMPORARY);
	}