1 /* Core dump and executable file functions above target vector, 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 #include <signal.h> 22 #include <fcntl.h> 23 #include "inferior.h" 24 #include "symtab.h" 25 #include "command.h" 26 #include "gdbcmd.h" 27 #include "bfd.h" 28 #include "target.h" 29 #include "gdbcore.h" 30 #include "dis-asm.h" 31 #include <sys/stat.h> 32 #include "completer.h" 33 #include "observable.h" 34 #include "cli/cli-utils.h" 35 #include "gdbarch.h" 36 37 /* You can have any number of hooks for `exec_file_command' command to 38 call. If there's only one hook, it is set in exec_file_display 39 hook. If there are two or more hooks, they are set in 40 exec_file_extra_hooks[], and deprecated_exec_file_display_hook is 41 set to a function that calls all of them. This extra complexity is 42 needed to preserve compatibility with old code that assumed that 43 only one hook could be set, and which called 44 deprecated_exec_file_display_hook directly. */ 45 46 typedef void (*hook_type) (const char *); 47 48 hook_type deprecated_exec_file_display_hook; /* The original hook. */ 49 static hook_type *exec_file_extra_hooks; /* Array of additional 50 hooks. */ 51 static int exec_file_hook_count = 0; /* Size of array. */ 52 53 54 55 /* If there are two or more functions that wish to hook into 56 exec_file_command, this function will call all of the hook 57 functions. */ 58 59 static void 60 call_extra_exec_file_hooks (const char *filename) 61 { 62 int i; 63 64 for (i = 0; i < exec_file_hook_count; i++) 65 (*exec_file_extra_hooks[i]) (filename); 66 } 67 68 /* Call this to specify the hook for exec_file_command to call back. 69 This is called from the x-window display code. */ 70 71 void 72 specify_exec_file_hook (void (*hook) (const char *)) 73 { 74 hook_type *new_array; 75 76 if (deprecated_exec_file_display_hook != NULL) 77 { 78 /* There's already a hook installed. Arrange to have both it 79 and the subsequent hooks called. */ 80 if (exec_file_hook_count == 0) 81 { 82 /* If this is the first extra hook, initialize the hook 83 array. */ 84 exec_file_extra_hooks = XNEW (hook_type); 85 exec_file_extra_hooks[0] = deprecated_exec_file_display_hook; 86 deprecated_exec_file_display_hook = call_extra_exec_file_hooks; 87 exec_file_hook_count = 1; 88 } 89 90 /* Grow the hook array by one and add the new hook to the end. 91 Yes, it's inefficient to grow it by one each time but since 92 this is hardly ever called it's not a big deal. */ 93 exec_file_hook_count++; 94 new_array = (hook_type *) 95 xrealloc (exec_file_extra_hooks, 96 exec_file_hook_count * sizeof (hook_type)); 97 exec_file_extra_hooks = new_array; 98 exec_file_extra_hooks[exec_file_hook_count - 1] = hook; 99 } 100 else 101 deprecated_exec_file_display_hook = hook; 102 } 103 104 void 105 reopen_exec_file (void) 106 { 107 int res; 108 struct stat st; 109 110 /* Don't do anything if there isn't an exec file. */ 111 if (current_program_space->exec_bfd () == NULL) 112 return; 113 114 /* If the timestamp of the exec file has changed, reopen it. */ 115 std::string filename = bfd_get_filename (current_program_space->exec_bfd ()); 116 res = stat (filename.c_str (), &st); 117 118 if (res == 0 119 && current_program_space->ebfd_mtime 120 && current_program_space->ebfd_mtime != st.st_mtime) 121 exec_file_attach (filename.c_str (), 0); 122 else 123 /* If we accessed the file since last opening it, close it now; 124 this stops GDB from holding the executable open after it 125 exits. */ 126 bfd_cache_close_all (); 127 } 128 129 /* If we have both a core file and an exec file, 130 print a warning if they don't go together. */ 131 132 void 133 validate_files (void) 134 { 135 if (current_program_space->exec_bfd () && core_bfd) 136 { 137 if (!core_file_matches_executable_p (core_bfd, 138 current_program_space->exec_bfd ())) 139 warning (_("core file may not match specified executable file.")); 140 else if (bfd_get_mtime (current_program_space->exec_bfd ()) 141 > bfd_get_mtime (core_bfd)) 142 warning (_("exec file is newer than core file.")); 143 } 144 } 145 146 /* See gdbsupport/common-inferior.h. */ 147 148 const char * 149 get_exec_file (int err) 150 { 151 if (current_program_space->exec_filename != nullptr) 152 return current_program_space->exec_filename.get (); 153 if (!err) 154 return NULL; 155 156 error (_("No executable file specified.\n\ 157 Use the \"file\" or \"exec-file\" command.")); 158 } 159 160 161 std::string 162 memory_error_message (enum target_xfer_status err, 163 struct gdbarch *gdbarch, CORE_ADDR memaddr) 164 { 165 switch (err) 166 { 167 case TARGET_XFER_E_IO: 168 /* Actually, address between memaddr and memaddr + len was out of 169 bounds. */ 170 return string_printf (_("Cannot access memory at address %s"), 171 paddress (gdbarch, memaddr)); 172 case TARGET_XFER_UNAVAILABLE: 173 return string_printf (_("Memory at address %s unavailable."), 174 paddress (gdbarch, memaddr)); 175 default: 176 internal_error ("unhandled target_xfer_status: %s (%s)", 177 target_xfer_status_to_string (err), 178 plongest (err)); 179 } 180 } 181 182 /* Report a memory error by throwing a suitable exception. */ 183 184 void 185 memory_error (enum target_xfer_status err, CORE_ADDR memaddr) 186 { 187 enum errors exception = GDB_NO_ERROR; 188 189 /* Build error string. */ 190 std::string str = memory_error_message (err, target_gdbarch (), memaddr); 191 192 /* Choose the right error to throw. */ 193 switch (err) 194 { 195 case TARGET_XFER_E_IO: 196 exception = MEMORY_ERROR; 197 break; 198 case TARGET_XFER_UNAVAILABLE: 199 exception = NOT_AVAILABLE_ERROR; 200 break; 201 } 202 203 /* Throw it. */ 204 throw_error (exception, ("%s"), str.c_str ()); 205 } 206 207 /* Helper function. */ 208 209 static void 210 read_memory_object (enum target_object object, CORE_ADDR memaddr, 211 gdb_byte *myaddr, ssize_t len) 212 { 213 ULONGEST xfered = 0; 214 215 while (xfered < len) 216 { 217 enum target_xfer_status status; 218 ULONGEST xfered_len; 219 220 status = target_xfer_partial (current_inferior ()->top_target (), object, 221 NULL, myaddr + xfered, NULL, 222 memaddr + xfered, len - xfered, 223 &xfered_len); 224 225 if (status != TARGET_XFER_OK) 226 memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status, 227 memaddr + xfered); 228 229 xfered += xfered_len; 230 QUIT; 231 } 232 } 233 234 /* Same as target_read_memory, but report an error if can't read. */ 235 236 void 237 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len) 238 { 239 read_memory_object (TARGET_OBJECT_MEMORY, memaddr, myaddr, len); 240 } 241 242 /* Same as target_read_stack, but report an error if can't read. */ 243 244 void 245 read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len) 246 { 247 read_memory_object (TARGET_OBJECT_STACK_MEMORY, memaddr, myaddr, len); 248 } 249 250 /* Same as target_read_code, but report an error if can't read. */ 251 252 void 253 read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len) 254 { 255 read_memory_object (TARGET_OBJECT_CODE_MEMORY, memaddr, myaddr, len); 256 } 257 258 /* Read memory at MEMADDR of length LEN and put the contents in 259 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero 260 if successful. */ 261 262 int 263 safe_read_memory_integer (CORE_ADDR memaddr, int len, 264 enum bfd_endian byte_order, 265 LONGEST *return_value) 266 { 267 gdb_byte buf[sizeof (LONGEST)]; 268 269 if (target_read_memory (memaddr, buf, len)) 270 return 0; 271 272 *return_value = extract_signed_integer (buf, len, byte_order); 273 return 1; 274 } 275 276 /* Read memory at MEMADDR of length LEN and put the contents in 277 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero 278 if successful. */ 279 280 int 281 safe_read_memory_unsigned_integer (CORE_ADDR memaddr, int len, 282 enum bfd_endian byte_order, 283 ULONGEST *return_value) 284 { 285 gdb_byte buf[sizeof (ULONGEST)]; 286 287 if (target_read_memory (memaddr, buf, len)) 288 return 0; 289 290 *return_value = extract_unsigned_integer (buf, len, byte_order); 291 return 1; 292 } 293 294 LONGEST 295 read_memory_integer (CORE_ADDR memaddr, int len, 296 enum bfd_endian byte_order) 297 { 298 gdb_byte buf[sizeof (LONGEST)]; 299 300 read_memory (memaddr, buf, len); 301 return extract_signed_integer (buf, len, byte_order); 302 } 303 304 ULONGEST 305 read_memory_unsigned_integer (CORE_ADDR memaddr, int len, 306 enum bfd_endian byte_order) 307 { 308 gdb_byte buf[sizeof (ULONGEST)]; 309 310 read_memory (memaddr, buf, len); 311 return extract_unsigned_integer (buf, len, byte_order); 312 } 313 314 LONGEST 315 read_code_integer (CORE_ADDR memaddr, int len, 316 enum bfd_endian byte_order) 317 { 318 gdb_byte buf[sizeof (LONGEST)]; 319 320 read_code (memaddr, buf, len); 321 return extract_signed_integer (buf, len, byte_order); 322 } 323 324 ULONGEST 325 read_code_unsigned_integer (CORE_ADDR memaddr, int len, 326 enum bfd_endian byte_order) 327 { 328 gdb_byte buf[sizeof (ULONGEST)]; 329 330 read_code (memaddr, buf, len); 331 return extract_unsigned_integer (buf, len, byte_order); 332 } 333 334 CORE_ADDR 335 read_memory_typed_address (CORE_ADDR addr, struct type *type) 336 { 337 gdb_byte *buf = (gdb_byte *) alloca (type->length ()); 338 339 read_memory (addr, buf, type->length ()); 340 return extract_typed_address (buf, type); 341 } 342 343 /* See gdbcore.h. */ 344 345 void 346 write_memory (CORE_ADDR memaddr, 347 const bfd_byte *myaddr, ssize_t len) 348 { 349 int status; 350 351 status = target_write_memory (memaddr, myaddr, len); 352 if (status != 0) 353 memory_error (TARGET_XFER_E_IO, memaddr); 354 } 355 356 /* Same as write_memory, but notify 'memory_changed' observers. */ 357 358 void 359 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr, 360 ssize_t len) 361 { 362 write_memory (memaddr, myaddr, len); 363 gdb::observers::memory_changed.notify (current_inferior (), memaddr, len, myaddr); 364 } 365 366 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned 367 integer. */ 368 void 369 write_memory_unsigned_integer (CORE_ADDR addr, int len, 370 enum bfd_endian byte_order, 371 ULONGEST value) 372 { 373 gdb_byte *buf = (gdb_byte *) alloca (len); 374 375 store_unsigned_integer (buf, len, byte_order, value); 376 write_memory (addr, buf, len); 377 } 378 379 /* Store VALUE at ADDR in the inferior as a LEN-byte signed 380 integer. */ 381 void 382 write_memory_signed_integer (CORE_ADDR addr, int len, 383 enum bfd_endian byte_order, 384 LONGEST value) 385 { 386 gdb_byte *buf = (gdb_byte *) alloca (len); 387 388 store_signed_integer (buf, len, byte_order, value); 389 write_memory (addr, buf, len); 390 } 391 392 /* The current default bfd target. Points to storage allocated for 393 gnutarget_string. */ 394 const char *gnutarget; 395 396 /* Same thing, except it is "auto" not NULL for the default case. */ 397 static std::string gnutarget_string; 398 static void 399 show_gnutarget_string (struct ui_file *file, int from_tty, 400 struct cmd_list_element *c, 401 const char *value) 402 { 403 gdb_printf (file, 404 _("The current BFD target is \"%s\".\n"), value); 405 } 406 407 static void 408 set_gnutarget_command (const char *ignore, int from_tty, 409 struct cmd_list_element *c) 410 { 411 const char *gend = gnutarget_string.c_str () + gnutarget_string.size (); 412 gend = remove_trailing_whitespace (gnutarget_string.c_str (), gend); 413 gnutarget_string 414 = gnutarget_string.substr (0, gend - gnutarget_string.data ()); 415 416 if (gnutarget_string == "auto") 417 gnutarget = NULL; 418 else 419 gnutarget = gnutarget_string.c_str (); 420 } 421 422 /* A completion function for "set gnutarget". */ 423 424 static void 425 complete_set_gnutarget (struct cmd_list_element *cmd, 426 completion_tracker &tracker, 427 const char *text, const char *word) 428 { 429 static const char **bfd_targets; 430 431 if (bfd_targets == NULL) 432 { 433 int last; 434 435 bfd_targets = bfd_target_list (); 436 for (last = 0; bfd_targets[last] != NULL; ++last) 437 ; 438 439 bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2); 440 bfd_targets[last] = "auto"; 441 bfd_targets[last + 1] = NULL; 442 } 443 444 complete_on_enum (tracker, bfd_targets, text, word); 445 } 446 447 /* Set the gnutarget. */ 448 void 449 set_gnutarget (const char *newtarget) 450 { 451 gnutarget_string = newtarget; 452 set_gnutarget_command (NULL, 0, NULL); 453 } 454 455 void _initialize_core (); 456 void 457 _initialize_core () 458 { 459 cmd_list_element *core_file_cmd 460 = add_cmd ("core-file", class_files, core_file_command, _("\ 461 Use FILE as core dump for examining memory and registers.\n\ 462 Usage: core-file FILE\n\ 463 No arg means have no core file. This command has been superseded by the\n\ 464 `target core' and `detach' commands."), &cmdlist); 465 set_cmd_completer (core_file_cmd, filename_completer); 466 467 468 set_show_commands set_show_gnutarget 469 = add_setshow_string_noescape_cmd ("gnutarget", class_files, 470 &gnutarget_string, _("\ 471 Set the current BFD target."), _("\ 472 Show the current BFD target."), _("\ 473 Use `set gnutarget auto' to specify automatic detection."), 474 set_gnutarget_command, 475 show_gnutarget_string, 476 &setlist, &showlist); 477 set_cmd_completer (set_show_gnutarget.set, complete_set_gnutarget); 478 479 add_alias_cmd ("g", set_show_gnutarget.set, class_files, 1, &setlist); 480 481 if (getenv ("GNUTARGET")) 482 set_gnutarget (getenv ("GNUTARGET")); 483 else 484 set_gnutarget ("auto"); 485 } 486