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 36 struct 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 72 int 73 solib_catchpoint::insert_location (struct bp_location *ignore) 74 { 75 return 0; 76 } 77 78 int 79 solib_catchpoint::remove_location (struct bp_location *ignore, 80 enum remove_bp_reason reason) 81 { 82 return 0; 83 } 84 85 int 86 solib_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 115 void 116 solib_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 141 enum print_stop_action 142 solib_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 161 bool 162 solib_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 203 void 204 solib_catchpoint::print_mention () const 205 { 206 gdb_printf (_("Catchpoint %d (%s)"), number, 207 is_load ? "load" : "unload"); 208 } 209 210 void 211 solib_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 223 void 224 add_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 246 static void 247 catch_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 256 static void 257 catch_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 263 static void 264 catch_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 270 void _initialize_break_catch_load (); 271 void 272 _initialize_break_catch_load () 273 { 274 add_catch_command ("load", _("Catch loads of shared libraries.\n\ 275 Usage: catch load [REGEX]\n\ 276 If 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\ 282 Usage: catch unload [REGEX]\n\ 283 If 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