1/* Everything about load/unload catchpoints, for GDB.
2
3   Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5   This file is part of GDB.
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 3 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20#include "defs.h"
21
22#include "annotate.h"
23#include "arch-utils.h"
24#include "breakpoint.h"
25#include "cli/cli-decode.h"
26#include "mi/mi-common.h"
27#include "progspace.h"
28#include "solist.h"
29#include "target.h"
30#include "valprint.h"
31
32/* An instance of this type is used to represent an solib catchpoint.
33   A breakpoint is really of this type iff its ops pointer points to
34   CATCH_SOLIB_BREAKPOINT_OPS.  */
35
36struct solib_catchpoint : public catchpoint
37{
38  solib_catchpoint (struct gdbarch *gdbarch, bool temp,
39		    const char *cond_string,
40		    bool is_load_, const char *arg)
41    : catchpoint (gdbarch, temp, cond_string),
42      is_load (is_load_),
43      regex (arg == nullptr ? nullptr : make_unique_xstrdup (arg)),
44      compiled (arg == nullptr
45		? nullptr
46		: new compiled_regex (arg, REG_NOSUB, _("Invalid regexp")))
47  {
48  }
49
50  int insert_location (struct bp_location *) override;
51  int remove_location (struct bp_location *,
52		       enum remove_bp_reason reason) override;
53  int breakpoint_hit (const struct bp_location *bl,
54		      const address_space *aspace,
55		      CORE_ADDR bp_addr,
56		      const target_waitstatus &ws) override;
57  void check_status (struct bpstat *bs) override;
58  enum print_stop_action print_it (const bpstat *bs) const override;
59  bool print_one (bp_location **) const override;
60  void print_mention () const override;
61  void print_recreate (struct ui_file *fp) const override;
62
63  /* True for "catch load", false for "catch unload".  */
64  bool is_load;
65
66  /* Regular expression to match, if any.  COMPILED is only valid when
67     REGEX is non-NULL.  */
68  gdb::unique_xmalloc_ptr<char> regex;
69  std::unique_ptr<compiled_regex> compiled;
70};
71
72int
73solib_catchpoint::insert_location (struct bp_location *ignore)
74{
75  return 0;
76}
77
78int
79solib_catchpoint::remove_location (struct bp_location *ignore,
80				   enum remove_bp_reason reason)
81{
82  return 0;
83}
84
85int
86solib_catchpoint::breakpoint_hit (const struct bp_location *bl,
87				  const address_space *aspace,
88				  CORE_ADDR bp_addr,
89				  const target_waitstatus &ws)
90{
91  if (ws.kind () == TARGET_WAITKIND_LOADED)
92    return 1;
93
94  for (breakpoint *other : all_breakpoints ())
95    {
96      if (other == bl->owner)
97	continue;
98
99      if (other->type != bp_shlib_event)
100	continue;
101
102      if (pspace != NULL && other->pspace != pspace)
103	continue;
104
105      for (bp_location *other_bl : other->locations ())
106	{
107	  if (other->breakpoint_hit (other_bl, aspace, bp_addr, ws))
108	    return 1;
109	}
110    }
111
112  return 0;
113}
114
115void
116solib_catchpoint::check_status (struct bpstat *bs)
117{
118  if (is_load)
119    {
120      for (so_list *iter : current_program_space->added_solibs)
121	{
122	  if (!regex
123	      || compiled->exec (iter->so_name, 0, NULL, 0) == 0)
124	    return;
125	}
126    }
127  else
128    {
129      for (const std::string &iter : current_program_space->deleted_solibs)
130	{
131	  if (!regex
132	      || compiled->exec (iter.c_str (), 0, NULL, 0) == 0)
133	    return;
134	}
135    }
136
137  bs->stop = 0;
138  bs->print_it = print_it_noop;
139}
140
141enum print_stop_action
142solib_catchpoint::print_it (const bpstat *bs) const
143{
144  struct breakpoint *b = bs->breakpoint_at;
145  struct ui_out *uiout = current_uiout;
146
147  annotate_catchpoint (b->number);
148  maybe_print_thread_hit_breakpoint (uiout);
149  if (b->disposition == disp_del)
150    uiout->text ("Temporary catchpoint ");
151  else
152    uiout->text ("Catchpoint ");
153  uiout->field_signed ("bkptno", b->number);
154  uiout->text ("\n");
155  if (uiout->is_mi_like_p ())
156    uiout->field_string ("disp", bpdisp_text (b->disposition));
157  print_solib_event (true);
158  return PRINT_SRC_AND_LOC;
159}
160
161bool
162solib_catchpoint::print_one (bp_location **locs) const
163{
164  struct value_print_options opts;
165  struct ui_out *uiout = current_uiout;
166
167  get_user_print_options (&opts);
168  /* Field 4, the address, is omitted (which makes the columns not
169     line up too nicely with the headers, but the effect is relatively
170     readable).  */
171  if (opts.addressprint)
172    {
173      annotate_field (4);
174      uiout->field_skip ("addr");
175    }
176
177  std::string msg;
178  annotate_field (5);
179  if (is_load)
180    {
181      if (regex)
182	msg = string_printf (_("load of library matching %s"),
183			     regex.get ());
184      else
185	msg = _("load of library");
186    }
187  else
188    {
189      if (regex)
190	msg = string_printf (_("unload of library matching %s"),
191			     regex.get ());
192      else
193	msg = _("unload of library");
194    }
195  uiout->field_string ("what", msg);
196
197  if (uiout->is_mi_like_p ())
198    uiout->field_string ("catch-type", is_load ? "load" : "unload");
199
200  return true;
201}
202
203void
204solib_catchpoint::print_mention () const
205{
206  gdb_printf (_("Catchpoint %d (%s)"), number,
207	      is_load ? "load" : "unload");
208}
209
210void
211solib_catchpoint::print_recreate (struct ui_file *fp) const
212{
213  gdb_printf (fp, "%s %s",
214	      disposition == disp_del ? "tcatch" : "catch",
215	      is_load ? "load" : "unload");
216  if (regex)
217    gdb_printf (fp, " %s", regex.get ());
218  gdb_printf (fp, "\n");
219}
220
221/* See breakpoint.h.  */
222
223void
224add_solib_catchpoint (const char *arg, bool is_load, bool is_temp, bool enabled)
225{
226  struct gdbarch *gdbarch = get_current_arch ();
227
228  if (!arg)
229    arg = "";
230  arg = skip_spaces (arg);
231  if (*arg == '\0')
232    arg = nullptr;
233
234  std::unique_ptr<solib_catchpoint> c (new solib_catchpoint (gdbarch, is_temp,
235							     nullptr,
236							     is_load, arg));
237
238  c->enable_state = enabled ? bp_enabled : bp_disabled;
239
240  install_breakpoint (0, std::move (c), 1);
241}
242
243/* A helper function that does all the work for "catch load" and
244   "catch unload".  */
245
246static void
247catch_load_or_unload (const char *arg, int from_tty, int is_load,
248		      struct cmd_list_element *command)
249{
250  const int enabled = 1;
251  bool temp = command->context () == CATCH_TEMPORARY;
252
253  add_solib_catchpoint (arg, is_load, temp, enabled);
254}
255
256static void
257catch_load_command_1 (const char *arg, int from_tty,
258		      struct cmd_list_element *command)
259{
260  catch_load_or_unload (arg, from_tty, 1, command);
261}
262
263static void
264catch_unload_command_1 (const char *arg, int from_tty,
265			struct cmd_list_element *command)
266{
267  catch_load_or_unload (arg, from_tty, 0, command);
268}
269
270void _initialize_break_catch_load ();
271void
272_initialize_break_catch_load ()
273{
274  add_catch_command ("load", _("Catch loads of shared libraries.\n\
275Usage: catch load [REGEX]\n\
276If REGEX is given, only stop for libraries matching the regular expression."),
277		     catch_load_command_1,
278		     NULL,
279		     CATCH_PERMANENT,
280		     CATCH_TEMPORARY);
281  add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
282Usage: catch unload [REGEX]\n\
283If REGEX is given, only stop for libraries matching the regular expression."),
284		     catch_unload_command_1,
285		     NULL,
286		     CATCH_PERMANENT,
287		     CATCH_TEMPORARY);
288}
289