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