1/* Memory-access and commands for "inferior" process, for GDB. 2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 3 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23#include "defs.h" 24#include <signal.h> 25#include "gdb_string.h" 26#include "symtab.h" 27#include "gdbtypes.h" 28#include "frame.h" 29#include "inferior.h" 30#include "environ.h" 31#include "value.h" 32#include "gdbcmd.h" 33#include "symfile.h" 34#include "gdbcore.h" 35#include "target.h" 36#include "language.h" 37#include "symfile.h" 38#include "objfiles.h" 39#include "completer.h" 40#include "ui-out.h" 41#include "event-top.h" 42#include "parser-defs.h" 43#include "regcache.h" 44#include "reggroups.h" 45#include "block.h" 46#include <ctype.h> 47#include "gdb_assert.h" 48 49/* Functions exported for general use, in inferior.h: */ 50 51void all_registers_info (char *, int); 52 53void registers_info (char *, int); 54 55void nexti_command (char *, int); 56 57void stepi_command (char *, int); 58 59void continue_command (char *, int); 60 61void interrupt_target_command (char *args, int from_tty); 62 63/* Local functions: */ 64 65static void nofp_registers_info (char *, int); 66 67static void print_return_value (int struct_return, struct type *value_type); 68 69static void finish_command_continuation (struct continuation_arg *); 70 71static void until_next_command (int); 72 73static void until_command (char *, int); 74 75static void path_info (char *, int); 76 77static void path_command (char *, int); 78 79static void unset_command (char *, int); 80 81static void float_info (char *, int); 82 83static void detach_command (char *, int); 84 85static void disconnect_command (char *, int); 86 87static void unset_environment_command (char *, int); 88 89static void set_environment_command (char *, int); 90 91static void environment_info (char *, int); 92 93static void program_info (char *, int); 94 95static void finish_command (char *, int); 96 97static void signal_command (char *, int); 98 99static void jump_command (char *, int); 100 101static void step_1 (int, int, char *); 102static void step_once (int skip_subroutines, int single_inst, int count); 103static void step_1_continuation (struct continuation_arg *arg); 104 105static void next_command (char *, int); 106 107static void step_command (char *, int); 108 109static void run_command (char *, int); 110 111static void run_no_args_command (char *args, int from_tty); 112 113static void go_command (char *line_no, int from_tty); 114 115static int strip_bg_char (char **); 116 117void _initialize_infcmd (void); 118 119#define GO_USAGE "Usage: go <location>\n" 120 121#define ERROR_NO_INFERIOR \ 122 if (!target_has_execution) error ("The program is not being run."); 123 124/* String containing arguments to give to the program, separated by spaces. 125 Empty string (pointer to '\0') means no args. */ 126 127static char *inferior_args; 128 129/* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero, 130 then we must compute INFERIOR_ARGS from this (via the target). */ 131 132static int inferior_argc; 133static char **inferior_argv; 134 135/* File name for default use for standard in/out in the inferior. */ 136 137char *inferior_io_terminal; 138 139/* Pid of our debugged inferior, or 0 if no inferior now. 140 Since various parts of infrun.c test this to see whether there is a program 141 being debugged it should be nonzero (currently 3 is used) for remote 142 debugging. */ 143 144ptid_t inferior_ptid; 145 146/* Last signal that the inferior received (why it stopped). */ 147 148enum target_signal stop_signal; 149 150/* Address at which inferior stopped. */ 151 152CORE_ADDR stop_pc; 153 154/* Chain containing status of breakpoint(s) that we have stopped at. */ 155 156bpstat stop_bpstat; 157 158/* Flag indicating that a command has proceeded the inferior past the 159 current breakpoint. */ 160 161int breakpoint_proceeded; 162 163/* Nonzero if stopped due to a step command. */ 164 165int stop_step; 166 167/* Nonzero if stopped due to completion of a stack dummy routine. */ 168 169int stop_stack_dummy; 170 171/* Nonzero if stopped due to a random (unexpected) signal in inferior 172 process. */ 173 174int stopped_by_random_signal; 175 176/* Range to single step within. 177 If this is nonzero, respond to a single-step signal 178 by continuing to step if the pc is in this range. */ 179 180CORE_ADDR step_range_start; /* Inclusive */ 181CORE_ADDR step_range_end; /* Exclusive */ 182 183/* Stack frame address as of when stepping command was issued. 184 This is how we know when we step into a subroutine call, 185 and how to set the frame for the breakpoint used to step out. */ 186 187struct frame_id step_frame_id; 188 189/* Our notion of the current stack pointer. */ 190 191CORE_ADDR step_sp; 192 193enum step_over_calls_kind step_over_calls; 194 195/* If stepping, nonzero means step count is > 1 196 so don't print frame next time inferior stops 197 if it stops due to stepping. */ 198 199int step_multi; 200 201/* Environment to use for running inferior, 202 in format described in environ.h. */ 203 204struct environ *inferior_environ; 205 206/* Accessor routines. */ 207 208char * 209get_inferior_args (void) 210{ 211 if (inferior_argc != 0) 212 { 213 char *n, *old; 214 215 n = gdbarch_construct_inferior_arguments (current_gdbarch, 216 inferior_argc, inferior_argv); 217 old = set_inferior_args (n); 218 xfree (old); 219 } 220 221 if (inferior_args == NULL) 222 inferior_args = xstrdup (""); 223 224 return inferior_args; 225} 226 227char * 228set_inferior_args (char *newargs) 229{ 230 char *saved_args = inferior_args; 231 232 inferior_args = newargs; 233 inferior_argc = 0; 234 inferior_argv = 0; 235 236 return saved_args; 237} 238 239void 240set_inferior_args_vector (int argc, char **argv) 241{ 242 inferior_argc = argc; 243 inferior_argv = argv; 244} 245 246/* Notice when `set args' is run. */ 247static void 248notice_args_set (char *args, int from_tty, struct cmd_list_element *c) 249{ 250 inferior_argc = 0; 251 inferior_argv = 0; 252} 253 254/* Notice when `show args' is run. */ 255static void 256notice_args_read (char *args, int from_tty, struct cmd_list_element *c) 257{ 258 /* Might compute the value. */ 259 get_inferior_args (); 260} 261 262 263/* Compute command-line string given argument vector. This does the 264 same shell processing as fork_inferior. */ 265char * 266construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv) 267{ 268 char *result; 269 270 if (STARTUP_WITH_SHELL) 271 { 272 /* This holds all the characters considered special to the 273 typical Unix shells. We include `^' because the SunOS 274 /bin/sh treats it as a synonym for `|'. */ 275 char *special = "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n"; 276 int i; 277 int length = 0; 278 char *out, *cp; 279 280 /* We over-compute the size. It shouldn't matter. */ 281 for (i = 0; i < argc; ++i) 282 length += 2 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0'); 283 284 result = (char *) xmalloc (length); 285 out = result; 286 287 for (i = 0; i < argc; ++i) 288 { 289 if (i > 0) 290 *out++ = ' '; 291 292 /* Need to handle empty arguments specially. */ 293 if (argv[i][0] == '\0') 294 { 295 *out++ = '\''; 296 *out++ = '\''; 297 } 298 else 299 { 300 for (cp = argv[i]; *cp; ++cp) 301 { 302 if (strchr (special, *cp) != NULL) 303 *out++ = '\\'; 304 *out++ = *cp; 305 } 306 } 307 } 308 *out = '\0'; 309 } 310 else 311 { 312 /* In this case we can't handle arguments that contain spaces, 313 tabs, or newlines -- see breakup_args(). */ 314 int i; 315 int length = 0; 316 317 for (i = 0; i < argc; ++i) 318 { 319 char *cp = strchr (argv[i], ' '); 320 if (cp == NULL) 321 cp = strchr (argv[i], '\t'); 322 if (cp == NULL) 323 cp = strchr (argv[i], '\n'); 324 if (cp != NULL) 325 error ("can't handle command-line argument containing whitespace"); 326 length += strlen (argv[i]) + 1; 327 } 328 329 result = (char *) xmalloc (length); 330 result[0] = '\0'; 331 for (i = 0; i < argc; ++i) 332 { 333 if (i > 0) 334 strcat (result, " "); 335 strcat (result, argv[i]); 336 } 337 } 338 339 return result; 340} 341 342 343/* This function detects whether or not a '&' character (indicating 344 background execution) has been added as *the last* of the arguments ARGS 345 of a command. If it has, it removes it and returns 1. Otherwise it 346 does nothing and returns 0. */ 347static int 348strip_bg_char (char **args) 349{ 350 char *p = NULL; 351 352 p = strchr (*args, '&'); 353 354 if (p) 355 { 356 if (p == (*args + strlen (*args) - 1)) 357 { 358 if (strlen (*args) > 1) 359 { 360 do 361 p--; 362 while (*p == ' ' || *p == '\t'); 363 *(p + 1) = '\0'; 364 } 365 else 366 *args = 0; 367 return 1; 368 } 369 } 370 return 0; 371} 372 373void 374tty_command (char *file, int from_tty) 375{ 376 if (file == 0) 377 error_no_arg ("terminal name for running target process"); 378 379 inferior_io_terminal = savestring (file, strlen (file)); 380} 381 382static void 383run_command (char *args, int from_tty) 384{ 385 char *exec_file; 386 387 dont_repeat (); 388 389 if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution) 390 { 391 if (from_tty 392 && !query ("The program being debugged has been started already.\n\ 393Start it from the beginning? ")) 394 error ("Program not restarted."); 395 target_kill (); 396#if defined(SOLIB_RESTART) 397 SOLIB_RESTART (); 398#endif 399 init_wait_for_inferior (); 400 } 401 402 clear_breakpoint_hit_counts (); 403 404 /* Purge old solib objfiles. */ 405 objfile_purge_solibs (); 406 407 do_run_cleanups (NULL); 408 409 /* The comment here used to read, "The exec file is re-read every 410 time we do a generic_mourn_inferior, so we just have to worry 411 about the symbol file." The `generic_mourn_inferior' function 412 gets called whenever the program exits. However, suppose the 413 program exits, and *then* the executable file changes? We need 414 to check again here. Since reopen_exec_file doesn't do anything 415 if the timestamp hasn't changed, I don't see the harm. */ 416 reopen_exec_file (); 417 reread_symbols (); 418 419 exec_file = (char *) get_exec_file (0); 420 421 /* We keep symbols from add-symbol-file, on the grounds that the 422 user might want to add some symbols before running the program 423 (right?). But sometimes (dynamic loading where the user manually 424 introduces the new symbols with add-symbol-file), the code which 425 the symbols describe does not persist between runs. Currently 426 the user has to manually nuke all symbols between runs if they 427 want them to go away (PR 2207). This is probably reasonable. */ 428 429 if (!args) 430 { 431 if (event_loop_p && target_can_async_p ()) 432 async_disable_stdin (); 433 } 434 else 435 { 436 int async_exec = strip_bg_char (&args); 437 438 /* If we get a request for running in the bg but the target 439 doesn't support it, error out. */ 440 if (event_loop_p && async_exec && !target_can_async_p ()) 441 error ("Asynchronous execution not supported on this target."); 442 443 /* If we don't get a request of running in the bg, then we need 444 to simulate synchronous (fg) execution. */ 445 if (event_loop_p && !async_exec && target_can_async_p ()) 446 { 447 /* Simulate synchronous execution */ 448 async_disable_stdin (); 449 } 450 451 /* If there were other args, beside '&', process them. */ 452 if (args) 453 { 454 char *old_args = set_inferior_args (xstrdup (args)); 455 xfree (old_args); 456 } 457 } 458 459 if (from_tty) 460 { 461 ui_out_field_string (uiout, NULL, "Starting program"); 462 ui_out_text (uiout, ": "); 463 if (exec_file) 464 ui_out_field_string (uiout, "execfile", exec_file); 465 ui_out_spaces (uiout, 1); 466 /* We call get_inferior_args() because we might need to compute 467 the value now. */ 468 ui_out_field_string (uiout, "infargs", get_inferior_args ()); 469 ui_out_text (uiout, "\n"); 470 ui_out_flush (uiout); 471 } 472 473 /* We call get_inferior_args() because we might need to compute 474 the value now. */ 475 target_create_inferior (exec_file, get_inferior_args (), 476 environ_vector (inferior_environ)); 477} 478 479 480static void 481run_no_args_command (char *args, int from_tty) 482{ 483 char *old_args = set_inferior_args (xstrdup ("")); 484 xfree (old_args); 485} 486 487 488void 489continue_command (char *proc_count_exp, int from_tty) 490{ 491 int async_exec = 0; 492 ERROR_NO_INFERIOR; 493 494 /* Find out whether we must run in the background. */ 495 if (proc_count_exp != NULL) 496 async_exec = strip_bg_char (&proc_count_exp); 497 498 /* If we must run in the background, but the target can't do it, 499 error out. */ 500 if (event_loop_p && async_exec && !target_can_async_p ()) 501 error ("Asynchronous execution not supported on this target."); 502 503 /* If we are not asked to run in the bg, then prepare to run in the 504 foreground, synchronously. */ 505 if (event_loop_p && !async_exec && target_can_async_p ()) 506 { 507 /* Simulate synchronous execution */ 508 async_disable_stdin (); 509 } 510 511 /* If have argument (besides '&'), set proceed count of breakpoint 512 we stopped at. */ 513 if (proc_count_exp != NULL) 514 { 515 bpstat bs = stop_bpstat; 516 int num = bpstat_num (&bs); 517 if (num == 0 && from_tty) 518 { 519 printf_filtered 520 ("Not stopped at any breakpoint; argument ignored.\n"); 521 } 522 while (num != 0) 523 { 524 set_ignore_count (num, 525 parse_and_eval_long (proc_count_exp) - 1, 526 from_tty); 527 /* set_ignore_count prints a message ending with a period. 528 So print two spaces before "Continuing.". */ 529 if (from_tty) 530 printf_filtered (" "); 531 num = bpstat_num (&bs); 532 } 533 } 534 535 if (from_tty) 536 printf_filtered ("Continuing.\n"); 537 538 clear_proceed_status (); 539 540 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0); 541} 542 543/* Step until outside of current statement. */ 544 545static void 546step_command (char *count_string, int from_tty) 547{ 548 step_1 (0, 0, count_string); 549} 550 551/* Likewise, but skip over subroutine calls as if single instructions. */ 552 553static void 554next_command (char *count_string, int from_tty) 555{ 556 step_1 (1, 0, count_string); 557} 558 559/* Likewise, but step only one instruction. */ 560 561void 562stepi_command (char *count_string, int from_tty) 563{ 564 step_1 (0, 1, count_string); 565} 566 567void 568nexti_command (char *count_string, int from_tty) 569{ 570 step_1 (1, 1, count_string); 571} 572 573static void 574disable_longjmp_breakpoint_cleanup (void *ignore) 575{ 576 disable_longjmp_breakpoint (); 577} 578 579static void 580step_1 (int skip_subroutines, int single_inst, char *count_string) 581{ 582 int count = 1; 583 struct frame_info *frame; 584 struct cleanup *cleanups = 0; 585 int async_exec = 0; 586 587 ERROR_NO_INFERIOR; 588 589 if (count_string) 590 async_exec = strip_bg_char (&count_string); 591 592 /* If we get a request for running in the bg but the target 593 doesn't support it, error out. */ 594 if (event_loop_p && async_exec && !target_can_async_p ()) 595 error ("Asynchronous execution not supported on this target."); 596 597 /* If we don't get a request of running in the bg, then we need 598 to simulate synchronous (fg) execution. */ 599 if (event_loop_p && !async_exec && target_can_async_p ()) 600 { 601 /* Simulate synchronous execution */ 602 async_disable_stdin (); 603 } 604 605 count = count_string ? parse_and_eval_long (count_string) : 1; 606 607 if (!single_inst || skip_subroutines) /* leave si command alone */ 608 { 609 enable_longjmp_breakpoint (); 610 if (!event_loop_p || !target_can_async_p ()) 611 cleanups = make_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/); 612 else 613 make_exec_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/); 614 } 615 616 /* In synchronous case, all is well, just use the regular for loop. */ 617 if (!event_loop_p || !target_can_async_p ()) 618 { 619 for (; count > 0; count--) 620 { 621 clear_proceed_status (); 622 623 frame = get_current_frame (); 624 if (!frame) /* Avoid coredump here. Why tho? */ 625 error ("No current frame"); 626 step_frame_id = get_frame_id (frame); 627 step_sp = read_sp (); 628 629 if (!single_inst) 630 { 631 find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end); 632 if (step_range_end == 0) 633 { 634 char *name; 635 if (find_pc_partial_function (stop_pc, &name, &step_range_start, 636 &step_range_end) == 0) 637 error ("Cannot find bounds of current function"); 638 639 target_terminal_ours (); 640 printf_filtered ("\ 641Single stepping until exit from function %s, \n\ 642which has no line number information.\n", name); 643 } 644 } 645 else 646 { 647 /* Say we are stepping, but stop after one insn whatever it does. */ 648 step_range_start = step_range_end = 1; 649 if (!skip_subroutines) 650 /* It is stepi. 651 Don't step over function calls, not even to functions lacking 652 line numbers. */ 653 step_over_calls = STEP_OVER_NONE; 654 } 655 656 if (skip_subroutines) 657 step_over_calls = STEP_OVER_ALL; 658 659 step_multi = (count > 1); 660 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1); 661 662 if (!stop_step) 663 break; 664 } 665 666 if (!single_inst || skip_subroutines) 667 do_cleanups (cleanups); 668 return; 669 } 670 /* In case of asynchronous target things get complicated, do only 671 one step for now, before returning control to the event loop. Let 672 the continuation figure out how many other steps we need to do, 673 and handle them one at the time, through step_once(). */ 674 else 675 { 676 if (event_loop_p && target_can_async_p ()) 677 step_once (skip_subroutines, single_inst, count); 678 } 679} 680 681/* Called after we are done with one step operation, to check whether 682 we need to step again, before we print the prompt and return control 683 to the user. If count is > 1, we will need to do one more call to 684 proceed(), via step_once(). Basically it is like step_once and 685 step_1_continuation are co-recursive. */ 686static void 687step_1_continuation (struct continuation_arg *arg) 688{ 689 int count; 690 int skip_subroutines; 691 int single_inst; 692 693 skip_subroutines = arg->data.integer; 694 single_inst = arg->next->data.integer; 695 count = arg->next->next->data.integer; 696 697 if (stop_step) 698 step_once (skip_subroutines, single_inst, count - 1); 699 else 700 if (!single_inst || skip_subroutines) 701 do_exec_cleanups (ALL_CLEANUPS); 702} 703 704/* Do just one step operation. If count >1 we will have to set up a 705 continuation to be done after the target stops (after this one 706 step). This is useful to implement the 'step n' kind of commands, in 707 case of asynchronous targets. We had to split step_1 into two parts, 708 one to be done before proceed() and one afterwards. This function is 709 called in case of step n with n>1, after the first step operation has 710 been completed.*/ 711static void 712step_once (int skip_subroutines, int single_inst, int count) 713{ 714 struct continuation_arg *arg1; 715 struct continuation_arg *arg2; 716 struct continuation_arg *arg3; 717 struct frame_info *frame; 718 719 if (count > 0) 720 { 721 clear_proceed_status (); 722 723 frame = get_current_frame (); 724 if (!frame) /* Avoid coredump here. Why tho? */ 725 error ("No current frame"); 726 step_frame_id = get_frame_id (frame); 727 step_sp = read_sp (); 728 729 if (!single_inst) 730 { 731 find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end); 732 733 /* If we have no line info, switch to stepi mode. */ 734 if (step_range_end == 0 && step_stop_if_no_debug) 735 { 736 step_range_start = step_range_end = 1; 737 } 738 else if (step_range_end == 0) 739 { 740 char *name; 741 if (find_pc_partial_function (stop_pc, &name, &step_range_start, 742 &step_range_end) == 0) 743 error ("Cannot find bounds of current function"); 744 745 target_terminal_ours (); 746 printf_filtered ("\ 747Single stepping until exit from function %s, \n\ 748which has no line number information.\n", name); 749 } 750 } 751 else 752 { 753 /* Say we are stepping, but stop after one insn whatever it does. */ 754 step_range_start = step_range_end = 1; 755 if (!skip_subroutines) 756 /* It is stepi. 757 Don't step over function calls, not even to functions lacking 758 line numbers. */ 759 step_over_calls = STEP_OVER_NONE; 760 } 761 762 if (skip_subroutines) 763 step_over_calls = STEP_OVER_ALL; 764 765 step_multi = (count > 1); 766 arg1 = 767 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 768 arg2 = 769 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 770 arg3 = 771 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 772 arg1->next = arg2; 773 arg1->data.integer = skip_subroutines; 774 arg2->next = arg3; 775 arg2->data.integer = single_inst; 776 arg3->next = NULL; 777 arg3->data.integer = count; 778 add_intermediate_continuation (step_1_continuation, arg1); 779 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1); 780 } 781} 782 783 784/* Continue program at specified address. */ 785 786static void 787jump_command (char *arg, int from_tty) 788{ 789 CORE_ADDR addr; 790 struct symtabs_and_lines sals; 791 struct symtab_and_line sal; 792 struct symbol *fn; 793 struct symbol *sfn; 794 int async_exec = 0; 795 796 ERROR_NO_INFERIOR; 797 798 /* Find out whether we must run in the background. */ 799 if (arg != NULL) 800 async_exec = strip_bg_char (&arg); 801 802 /* If we must run in the background, but the target can't do it, 803 error out. */ 804 if (event_loop_p && async_exec && !target_can_async_p ()) 805 error ("Asynchronous execution not supported on this target."); 806 807 /* If we are not asked to run in the bg, then prepare to run in the 808 foreground, synchronously. */ 809 if (event_loop_p && !async_exec && target_can_async_p ()) 810 { 811 /* Simulate synchronous execution */ 812 async_disable_stdin (); 813 } 814 815 if (!arg) 816 error_no_arg ("starting address"); 817 818 sals = decode_line_spec_1 (arg, 1); 819 if (sals.nelts != 1) 820 { 821 error ("Unreasonable jump request"); 822 } 823 824 sal = sals.sals[0]; 825 xfree (sals.sals); 826 827 if (sal.symtab == 0 && sal.pc == 0) 828 error ("No source file has been specified."); 829 830 resolve_sal_pc (&sal); /* May error out */ 831 832 /* See if we are trying to jump to another function. */ 833 fn = get_frame_function (get_current_frame ()); 834 sfn = find_pc_function (sal.pc); 835 if (fn != NULL && sfn != fn) 836 { 837 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal.line, 838 SYMBOL_PRINT_NAME (fn))) 839 { 840 error ("Not confirmed."); 841 /* NOTREACHED */ 842 } 843 } 844 845 if (sfn != NULL) 846 { 847 fixup_symbol_section (sfn, 0); 848 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn)) && 849 !section_is_mapped (SYMBOL_BFD_SECTION (sfn))) 850 { 851 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? ")) 852 { 853 error ("Not confirmed."); 854 /* NOTREACHED */ 855 } 856 } 857 } 858 859 addr = sal.pc; 860 861 if (from_tty) 862 { 863 printf_filtered ("Continuing at "); 864 print_address_numeric (addr, 1, gdb_stdout); 865 printf_filtered (".\n"); 866 } 867 868 clear_proceed_status (); 869 proceed (addr, TARGET_SIGNAL_0, 0); 870} 871 872 873/* Go to line or address in current procedure */ 874static void 875go_command (char *line_no, int from_tty) 876{ 877 if (line_no == (char *) NULL || !*line_no) 878 printf_filtered (GO_USAGE); 879 else 880 { 881 tbreak_command (line_no, from_tty); 882 jump_command (line_no, from_tty); 883 } 884} 885 886 887/* Continue program giving it specified signal. */ 888 889static void 890signal_command (char *signum_exp, int from_tty) 891{ 892 enum target_signal oursig; 893 894 dont_repeat (); /* Too dangerous. */ 895 ERROR_NO_INFERIOR; 896 897 if (!signum_exp) 898 error_no_arg ("signal number"); 899 900 /* It would be even slicker to make signal names be valid expressions, 901 (the type could be "enum $signal" or some such), then the user could 902 assign them to convenience variables. */ 903 oursig = target_signal_from_name (signum_exp); 904 905 if (oursig == TARGET_SIGNAL_UNKNOWN) 906 { 907 /* No, try numeric. */ 908 int num = parse_and_eval_long (signum_exp); 909 910 if (num == 0) 911 oursig = TARGET_SIGNAL_0; 912 else 913 oursig = target_signal_from_command (num); 914 } 915 916 if (from_tty) 917 { 918 if (oursig == TARGET_SIGNAL_0) 919 printf_filtered ("Continuing with no signal.\n"); 920 else 921 printf_filtered ("Continuing with signal %s.\n", 922 target_signal_to_name (oursig)); 923 } 924 925 clear_proceed_status (); 926 /* "signal 0" should not get stuck if we are stopped at a breakpoint. 927 FIXME: Neither should "signal foo" but when I tried passing 928 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't 929 tried to track down yet. */ 930 proceed (oursig == TARGET_SIGNAL_0 ? (CORE_ADDR) -1 : stop_pc, oursig, 0); 931} 932 933/* Proceed until we reach a different source line with pc greater than 934 our current one or exit the function. We skip calls in both cases. 935 936 Note that eventually this command should probably be changed so 937 that only source lines are printed out when we hit the breakpoint 938 we set. This may involve changes to wait_for_inferior and the 939 proceed status code. */ 940 941static void 942until_next_command (int from_tty) 943{ 944 struct frame_info *frame; 945 CORE_ADDR pc; 946 struct symbol *func; 947 struct symtab_and_line sal; 948 949 clear_proceed_status (); 950 951 frame = get_current_frame (); 952 953 /* Step until either exited from this function or greater 954 than the current line (if in symbolic section) or pc (if 955 not). */ 956 957 pc = read_pc (); 958 func = find_pc_function (pc); 959 960 if (!func) 961 { 962 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc); 963 964 if (msymbol == NULL) 965 error ("Execution is not within a known function."); 966 967 step_range_start = SYMBOL_VALUE_ADDRESS (msymbol); 968 step_range_end = pc; 969 } 970 else 971 { 972 sal = find_pc_line (pc, 0); 973 974 step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func)); 975 step_range_end = sal.end; 976 } 977 978 step_over_calls = STEP_OVER_ALL; 979 step_frame_id = get_frame_id (frame); 980 step_sp = read_sp (); 981 982 step_multi = 0; /* Only one call to proceed */ 983 984 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1); 985} 986 987static void 988until_command (char *arg, int from_tty) 989{ 990 int async_exec = 0; 991 992 if (!target_has_execution) 993 error ("The program is not running."); 994 995 /* Find out whether we must run in the background. */ 996 if (arg != NULL) 997 async_exec = strip_bg_char (&arg); 998 999 /* If we must run in the background, but the target can't do it, 1000 error out. */ 1001 if (event_loop_p && async_exec && !target_can_async_p ()) 1002 error ("Asynchronous execution not supported on this target."); 1003 1004 /* If we are not asked to run in the bg, then prepare to run in the 1005 foreground, synchronously. */ 1006 if (event_loop_p && !async_exec && target_can_async_p ()) 1007 { 1008 /* Simulate synchronous execution */ 1009 async_disable_stdin (); 1010 } 1011 1012 if (arg) 1013 until_break_command (arg, from_tty, 0); 1014 else 1015 until_next_command (from_tty); 1016} 1017 1018static void 1019advance_command (char *arg, int from_tty) 1020{ 1021 int async_exec = 0; 1022 1023 if (!target_has_execution) 1024 error ("The program is not running."); 1025 1026 if (arg == NULL) 1027 error_no_arg ("a location"); 1028 1029 /* Find out whether we must run in the background. */ 1030 if (arg != NULL) 1031 async_exec = strip_bg_char (&arg); 1032 1033 /* If we must run in the background, but the target can't do it, 1034 error out. */ 1035 if (event_loop_p && async_exec && !target_can_async_p ()) 1036 error ("Asynchronous execution not supported on this target."); 1037 1038 /* If we are not asked to run in the bg, then prepare to run in the 1039 foreground, synchronously. */ 1040 if (event_loop_p && !async_exec && target_can_async_p ()) 1041 { 1042 /* Simulate synchronous execution. */ 1043 async_disable_stdin (); 1044 } 1045 1046 until_break_command (arg, from_tty, 1); 1047} 1048 1049 1050/* Print the result of a function at the end of a 'finish' command. */ 1051 1052static void 1053print_return_value (int struct_return, struct type *value_type) 1054{ 1055 struct cleanup *old_chain; 1056 struct ui_stream *stb; 1057 struct value *value; 1058 1059 if (!struct_return) 1060 { 1061 /* The return value can be found in the inferior's registers. */ 1062 value = register_value_being_returned (value_type, stop_registers); 1063 } 1064 /* FIXME: cagney/2004-01-17: When both return_value and 1065 extract_returned_value_address are available, should use that to 1066 find the address of and then extract the returned value. */ 1067 /* FIXME: 2003-09-27: When returning from a nested inferior function 1068 call, it's possible (with no help from the architecture vector) 1069 to locate and return/print a "struct return" value. This is just 1070 a more complicated case of what is already being done in in the 1071 inferior function call code. In fact, when inferior function 1072 calls are made async, this will likely be made the norm. */ 1073 else if (gdbarch_return_value_p (current_gdbarch)) 1074 /* We cannot determine the contents of the structure because it is 1075 on the stack, and we don't know where, since we did not 1076 initiate the call, as opposed to the call_function_by_hand 1077 case. */ 1078 { 1079 gdb_assert (gdbarch_return_value (current_gdbarch, value_type, 1080 NULL, NULL, NULL) 1081 == RETURN_VALUE_STRUCT_CONVENTION); 1082 ui_out_text (uiout, "Value returned has type: "); 1083 ui_out_field_string (uiout, "return-type", TYPE_NAME (value_type)); 1084 ui_out_text (uiout, "."); 1085 ui_out_text (uiout, " Cannot determine contents\n"); 1086 return; 1087 } 1088 else 1089 { 1090 if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()) 1091 { 1092 CORE_ADDR addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers); 1093 if (!addr) 1094 error ("Function return value unknown."); 1095 value = value_at (value_type, addr, NULL); 1096 } 1097 else 1098 { 1099 /* It is "struct return" yet the value is being extracted, 1100 presumably from registers, using EXTRACT_RETURN_VALUE. 1101 This doesn't make sense. Unfortunately, the legacy 1102 interfaces allowed this behavior. Sigh! */ 1103 value = allocate_value (value_type); 1104 CHECK_TYPEDEF (value_type); 1105 /* If the function returns void, don't bother fetching the 1106 return value. */ 1107 EXTRACT_RETURN_VALUE (value_type, stop_registers, 1108 VALUE_CONTENTS_RAW (value)); 1109 } 1110 } 1111 1112 /* Print it. */ 1113 stb = ui_out_stream_new (uiout); 1114 old_chain = make_cleanup_ui_out_stream_delete (stb); 1115 ui_out_text (uiout, "Value returned is "); 1116 ui_out_field_fmt (uiout, "gdb-result-var", "$%d", 1117 record_latest_value (value)); 1118 ui_out_text (uiout, " = "); 1119 value_print (value, stb->stream, 0, Val_no_prettyprint); 1120 ui_out_field_stream (uiout, "return-value", stb); 1121 ui_out_text (uiout, "\n"); 1122 do_cleanups (old_chain); 1123} 1124 1125/* Stuff that needs to be done by the finish command after the target 1126 has stopped. In asynchronous mode, we wait for the target to stop 1127 in the call to poll or select in the event loop, so it is 1128 impossible to do all the stuff as part of the finish_command 1129 function itself. The only chance we have to complete this command 1130 is in fetch_inferior_event, which is called by the event loop as 1131 soon as it detects that the target has stopped. This function is 1132 called via the cmd_continuation pointer. */ 1133 1134static void 1135finish_command_continuation (struct continuation_arg *arg) 1136{ 1137 struct symbol *function; 1138 struct breakpoint *breakpoint; 1139 struct cleanup *cleanups; 1140 1141 breakpoint = (struct breakpoint *) arg->data.pointer; 1142 function = (struct symbol *) arg->next->data.pointer; 1143 cleanups = (struct cleanup *) arg->next->next->data.pointer; 1144 1145 if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL 1146 && function != NULL) 1147 { 1148 struct type *value_type; 1149 int struct_return; 1150 int gcc_compiled; 1151 1152 value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function)); 1153 if (!value_type) 1154 internal_error (__FILE__, __LINE__, 1155 "finish_command: function has no target type"); 1156 1157 if (TYPE_CODE (value_type) == TYPE_CODE_VOID) 1158 { 1159 do_exec_cleanups (cleanups); 1160 return; 1161 } 1162 1163 CHECK_TYPEDEF (value_type); 1164 gcc_compiled = BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)); 1165 struct_return = using_struct_return (value_type, gcc_compiled); 1166 1167 print_return_value (struct_return, value_type); 1168 } 1169 1170 do_exec_cleanups (cleanups); 1171} 1172 1173/* "finish": Set a temporary breakpoint at the place the selected 1174 frame will return to, then continue. */ 1175 1176static void 1177finish_command (char *arg, int from_tty) 1178{ 1179 struct symtab_and_line sal; 1180 struct frame_info *frame; 1181 struct symbol *function; 1182 struct breakpoint *breakpoint; 1183 struct cleanup *old_chain; 1184 struct continuation_arg *arg1, *arg2, *arg3; 1185 1186 int async_exec = 0; 1187 1188 /* Find out whether we must run in the background. */ 1189 if (arg != NULL) 1190 async_exec = strip_bg_char (&arg); 1191 1192 /* If we must run in the background, but the target can't do it, 1193 error out. */ 1194 if (event_loop_p && async_exec && !target_can_async_p ()) 1195 error ("Asynchronous execution not supported on this target."); 1196 1197 /* If we are not asked to run in the bg, then prepare to run in the 1198 foreground, synchronously. */ 1199 if (event_loop_p && !async_exec && target_can_async_p ()) 1200 { 1201 /* Simulate synchronous execution. */ 1202 async_disable_stdin (); 1203 } 1204 1205 if (arg) 1206 error ("The \"finish\" command does not take any arguments."); 1207 if (!target_has_execution) 1208 error ("The program is not running."); 1209 if (deprecated_selected_frame == NULL) 1210 error ("No selected frame."); 1211 1212 frame = get_prev_frame (deprecated_selected_frame); 1213 if (frame == 0) 1214 error ("\"finish\" not meaningful in the outermost frame."); 1215 1216 clear_proceed_status (); 1217 1218 sal = find_pc_line (get_frame_pc (frame), 0); 1219 sal.pc = get_frame_pc (frame); 1220 1221 breakpoint = set_momentary_breakpoint (sal, get_frame_id (frame), bp_finish); 1222 1223 if (!event_loop_p || !target_can_async_p ()) 1224 old_chain = make_cleanup_delete_breakpoint (breakpoint); 1225 else 1226 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint); 1227 1228 /* Find the function we will return from. */ 1229 1230 function = find_pc_function (get_frame_pc (deprecated_selected_frame)); 1231 1232 /* Print info on the selected frame, including level number but not 1233 source. */ 1234 if (from_tty) 1235 { 1236 printf_filtered ("Run till exit from "); 1237 print_stack_frame (deprecated_selected_frame, 1238 frame_relative_level (deprecated_selected_frame), 0); 1239 } 1240 1241 /* If running asynchronously and the target support asynchronous 1242 execution, set things up for the rest of the finish command to be 1243 completed later on, when gdb has detected that the target has 1244 stopped, in fetch_inferior_event. */ 1245 if (event_loop_p && target_can_async_p ()) 1246 { 1247 arg1 = 1248 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 1249 arg2 = 1250 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 1251 arg3 = 1252 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 1253 arg1->next = arg2; 1254 arg2->next = arg3; 1255 arg3->next = NULL; 1256 arg1->data.pointer = breakpoint; 1257 arg2->data.pointer = function; 1258 arg3->data.pointer = old_chain; 1259 add_continuation (finish_command_continuation, arg1); 1260 } 1261 1262 proceed_to_finish = 1; /* We want stop_registers, please... */ 1263 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0); 1264 1265 /* Do this only if not running asynchronously or if the target 1266 cannot do async execution. Otherwise, complete this command when 1267 the target actually stops, in fetch_inferior_event. */ 1268 if (!event_loop_p || !target_can_async_p ()) 1269 { 1270 /* Did we stop at our breakpoint? */ 1271 if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL 1272 && function != NULL) 1273 { 1274 struct type *value_type; 1275 int struct_return; 1276 int gcc_compiled; 1277 1278 value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function)); 1279 if (!value_type) 1280 internal_error (__FILE__, __LINE__, 1281 "finish_command: function has no target type"); 1282 1283 /* FIXME: Shouldn't we do the cleanups before returning? */ 1284 if (TYPE_CODE (value_type) == TYPE_CODE_VOID) 1285 return; 1286 1287 CHECK_TYPEDEF (value_type); 1288 gcc_compiled = BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)); 1289 struct_return = using_struct_return (value_type, gcc_compiled); 1290 1291 print_return_value (struct_return, value_type); 1292 } 1293 1294 do_cleanups (old_chain); 1295 } 1296} 1297 1298 1299static void 1300program_info (char *args, int from_tty) 1301{ 1302 bpstat bs = stop_bpstat; 1303 int num = bpstat_num (&bs); 1304 1305 if (!target_has_execution) 1306 { 1307 printf_filtered ("The program being debugged is not being run.\n"); 1308 return; 1309 } 1310 1311 target_files_info (); 1312 printf_filtered ("Program stopped at %s.\n", 1313 local_hex_string ((unsigned long) stop_pc)); 1314 if (stop_step) 1315 printf_filtered ("It stopped after being stepped.\n"); 1316 else if (num != 0) 1317 { 1318 /* There may be several breakpoints in the same place, so this 1319 isn't as strange as it seems. */ 1320 while (num != 0) 1321 { 1322 if (num < 0) 1323 { 1324 printf_filtered ("It stopped at a breakpoint that has "); 1325 printf_filtered ("since been deleted.\n"); 1326 } 1327 else 1328 printf_filtered ("It stopped at breakpoint %d.\n", num); 1329 num = bpstat_num (&bs); 1330 } 1331 } 1332 else if (stop_signal != TARGET_SIGNAL_0) 1333 { 1334 printf_filtered ("It stopped with signal %s, %s.\n", 1335 target_signal_to_name (stop_signal), 1336 target_signal_to_string (stop_signal)); 1337 } 1338 1339 if (!from_tty) 1340 { 1341 printf_filtered ("Type \"info stack\" or \"info registers\" "); 1342 printf_filtered ("for more information.\n"); 1343 } 1344} 1345 1346static void 1347environment_info (char *var, int from_tty) 1348{ 1349 if (var) 1350 { 1351 char *val = get_in_environ (inferior_environ, var); 1352 if (val) 1353 { 1354 puts_filtered (var); 1355 puts_filtered (" = "); 1356 puts_filtered (val); 1357 puts_filtered ("\n"); 1358 } 1359 else 1360 { 1361 puts_filtered ("Environment variable \""); 1362 puts_filtered (var); 1363 puts_filtered ("\" not defined.\n"); 1364 } 1365 } 1366 else 1367 { 1368 char **vector = environ_vector (inferior_environ); 1369 while (*vector) 1370 { 1371 puts_filtered (*vector++); 1372 puts_filtered ("\n"); 1373 } 1374 } 1375} 1376 1377static void 1378set_environment_command (char *arg, int from_tty) 1379{ 1380 char *p, *val, *var; 1381 int nullset = 0; 1382 1383 if (arg == 0) 1384 error_no_arg ("environment variable and value"); 1385 1386 /* Find seperation between variable name and value */ 1387 p = (char *) strchr (arg, '='); 1388 val = (char *) strchr (arg, ' '); 1389 1390 if (p != 0 && val != 0) 1391 { 1392 /* We have both a space and an equals. If the space is before the 1393 equals, walk forward over the spaces til we see a nonspace 1394 (possibly the equals). */ 1395 if (p > val) 1396 while (*val == ' ') 1397 val++; 1398 1399 /* Now if the = is after the char following the spaces, 1400 take the char following the spaces. */ 1401 if (p > val) 1402 p = val - 1; 1403 } 1404 else if (val != 0 && p == 0) 1405 p = val; 1406 1407 if (p == arg) 1408 error_no_arg ("environment variable to set"); 1409 1410 if (p == 0 || p[1] == 0) 1411 { 1412 nullset = 1; 1413 if (p == 0) 1414 p = arg + strlen (arg); /* So that savestring below will work */ 1415 } 1416 else 1417 { 1418 /* Not setting variable value to null */ 1419 val = p + 1; 1420 while (*val == ' ' || *val == '\t') 1421 val++; 1422 } 1423 1424 while (p != arg && (p[-1] == ' ' || p[-1] == '\t')) 1425 p--; 1426 1427 var = savestring (arg, p - arg); 1428 if (nullset) 1429 { 1430 printf_filtered ("Setting environment variable "); 1431 printf_filtered ("\"%s\" to null value.\n", var); 1432 set_in_environ (inferior_environ, var, ""); 1433 } 1434 else 1435 set_in_environ (inferior_environ, var, val); 1436 xfree (var); 1437} 1438 1439static void 1440unset_environment_command (char *var, int from_tty) 1441{ 1442 if (var == 0) 1443 { 1444 /* If there is no argument, delete all environment variables. 1445 Ask for confirmation if reading from the terminal. */ 1446 if (!from_tty || query ("Delete all environment variables? ")) 1447 { 1448 free_environ (inferior_environ); 1449 inferior_environ = make_environ (); 1450 } 1451 } 1452 else 1453 unset_in_environ (inferior_environ, var); 1454} 1455 1456/* Handle the execution path (PATH variable) */ 1457 1458static const char path_var_name[] = "PATH"; 1459 1460static void 1461path_info (char *args, int from_tty) 1462{ 1463 puts_filtered ("Executable and object file path: "); 1464 puts_filtered (get_in_environ (inferior_environ, path_var_name)); 1465 puts_filtered ("\n"); 1466} 1467 1468/* Add zero or more directories to the front of the execution path. */ 1469 1470static void 1471path_command (char *dirname, int from_tty) 1472{ 1473 char *exec_path; 1474 char *env; 1475 dont_repeat (); 1476 env = get_in_environ (inferior_environ, path_var_name); 1477 /* Can be null if path is not set */ 1478 if (!env) 1479 env = ""; 1480 exec_path = xstrdup (env); 1481 mod_path (dirname, &exec_path); 1482 set_in_environ (inferior_environ, path_var_name, exec_path); 1483 xfree (exec_path); 1484 if (from_tty) 1485 path_info ((char *) NULL, from_tty); 1486} 1487 1488 1489/* Print out the machine register regnum. If regnum is -1, print all 1490 registers (print_all == 1) or all non-float and non-vector 1491 registers (print_all == 0). 1492 1493 For most machines, having all_registers_info() print the 1494 register(s) one per line is good enough. If a different format is 1495 required, (eg, for MIPS or Pyramid 90x, which both have lots of 1496 regs), or there is an existing convention for showing all the 1497 registers, define the architecture method PRINT_REGISTERS_INFO to 1498 provide that format. */ 1499 1500void 1501default_print_registers_info (struct gdbarch *gdbarch, 1502 struct ui_file *file, 1503 struct frame_info *frame, 1504 int regnum, int print_all) 1505{ 1506 int i; 1507 const int numregs = NUM_REGS + NUM_PSEUDO_REGS; 1508 char raw_buffer[MAX_REGISTER_SIZE]; 1509 char virtual_buffer[MAX_REGISTER_SIZE]; 1510 1511 if (DEPRECATED_DO_REGISTERS_INFO_P ()) 1512 { 1513 DEPRECATED_DO_REGISTERS_INFO (regnum, print_all); 1514 return; 1515 } 1516 1517 for (i = 0; i < numregs; i++) 1518 { 1519 /* Decide between printing all regs, non-float / vector regs, or 1520 specific reg. */ 1521 if (regnum == -1) 1522 { 1523 if (print_all) 1524 { 1525 if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup)) 1526 continue; 1527 } 1528 else 1529 { 1530 if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup)) 1531 continue; 1532 } 1533 } 1534 else 1535 { 1536 if (i != regnum) 1537 continue; 1538 } 1539 1540 /* If the register name is empty, it is undefined for this 1541 processor, so don't display anything. */ 1542 if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0') 1543 continue; 1544 1545 fputs_filtered (REGISTER_NAME (i), file); 1546 print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), file); 1547 1548 /* Get the data in raw format. */ 1549 if (! frame_register_read (frame, i, raw_buffer)) 1550 { 1551 fprintf_filtered (file, "*value not available*\n"); 1552 continue; 1553 } 1554 1555 /* FIXME: cagney/2002-08-03: This code shouldn't be necessary. 1556 The function frame_register_read() should have returned the 1557 pre-cooked register so no conversion is necessary. */ 1558 /* Convert raw data to virtual format if necessary. */ 1559 if (DEPRECATED_REGISTER_CONVERTIBLE_P () 1560 && DEPRECATED_REGISTER_CONVERTIBLE (i)) 1561 { 1562 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (i, register_type (current_gdbarch, i), 1563 raw_buffer, virtual_buffer); 1564 } 1565 else 1566 { 1567 memcpy (virtual_buffer, raw_buffer, 1568 DEPRECATED_REGISTER_VIRTUAL_SIZE (i)); 1569 } 1570 1571 /* If virtual format is floating, print it that way, and in raw 1572 hex. */ 1573 if (TYPE_CODE (register_type (current_gdbarch, i)) == TYPE_CODE_FLT) 1574 { 1575 int j; 1576 1577 val_print (register_type (current_gdbarch, i), virtual_buffer, 0, 0, 1578 file, 0, 1, 0, Val_pretty_default); 1579 1580 fprintf_filtered (file, "\t(raw 0x"); 1581 for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++) 1582 { 1583 int idx; 1584 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 1585 idx = j; 1586 else 1587 idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j; 1588 fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]); 1589 } 1590 fprintf_filtered (file, ")"); 1591 } 1592 else 1593 { 1594 /* Print the register in hex. */ 1595 val_print (register_type (current_gdbarch, i), virtual_buffer, 0, 0, 1596 file, 'x', 1, 0, Val_pretty_default); 1597 /* If not a vector register, print it also according to its 1598 natural format. */ 1599 if (TYPE_VECTOR (register_type (current_gdbarch, i)) == 0) 1600 { 1601 fprintf_filtered (file, "\t"); 1602 val_print (register_type (current_gdbarch, i), virtual_buffer, 0, 0, 1603 file, 0, 1, 0, Val_pretty_default); 1604 } 1605 } 1606 1607 fprintf_filtered (file, "\n"); 1608 } 1609} 1610 1611void 1612registers_info (char *addr_exp, int fpregs) 1613{ 1614 int regnum, numregs; 1615 char *end; 1616 1617 if (!target_has_registers) 1618 error ("The program has no registers now."); 1619 if (deprecated_selected_frame == NULL) 1620 error ("No selected frame."); 1621 1622 if (!addr_exp) 1623 { 1624 gdbarch_print_registers_info (current_gdbarch, gdb_stdout, 1625 deprecated_selected_frame, -1, fpregs); 1626 return; 1627 } 1628 1629 while (*addr_exp != '\0') 1630 { 1631 char *start; 1632 const char *end; 1633 1634 /* Keep skipping leading white space. */ 1635 if (isspace ((*addr_exp))) 1636 { 1637 addr_exp++; 1638 continue; 1639 } 1640 1641 /* Discard any leading ``$''. Check that there is something 1642 resembling a register following it. */ 1643 if (addr_exp[0] == '$') 1644 addr_exp++; 1645 if (isspace ((*addr_exp)) || (*addr_exp) == '\0') 1646 error ("Missing register name"); 1647 1648 /* Find the start/end of this register name/num/group. */ 1649 start = addr_exp; 1650 while ((*addr_exp) != '\0' && !isspace ((*addr_exp))) 1651 addr_exp++; 1652 end = addr_exp; 1653 1654 /* Figure out what we've found and display it. */ 1655 1656 /* A register name? */ 1657 { 1658 int regnum = frame_map_name_to_regnum (deprecated_selected_frame, 1659 start, end - start); 1660 if (regnum >= 0) 1661 { 1662 gdbarch_print_registers_info (current_gdbarch, gdb_stdout, 1663 deprecated_selected_frame, regnum, fpregs); 1664 continue; 1665 } 1666 } 1667 1668 /* A register number? (how portable is this one?). */ 1669 { 1670 char *endptr; 1671 int regnum = strtol (start, &endptr, 0); 1672 if (endptr == end 1673 && regnum >= 0 1674 && regnum < NUM_REGS + NUM_PSEUDO_REGS) 1675 { 1676 gdbarch_print_registers_info (current_gdbarch, gdb_stdout, 1677 deprecated_selected_frame, regnum, fpregs); 1678 continue; 1679 } 1680 } 1681 1682 /* A register group? */ 1683 { 1684 struct reggroup *group; 1685 for (group = reggroup_next (current_gdbarch, NULL); 1686 group != NULL; 1687 group = reggroup_next (current_gdbarch, group)) 1688 { 1689 /* Don't bother with a length check. Should the user 1690 enter a short register group name, go with the first 1691 group that matches. */ 1692 if (strncmp (start, reggroup_name (group), end - start) == 0) 1693 break; 1694 } 1695 if (group != NULL) 1696 { 1697 int regnum; 1698 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) 1699 { 1700 if (gdbarch_register_reggroup_p (current_gdbarch, regnum, 1701 group)) 1702 gdbarch_print_registers_info (current_gdbarch, 1703 gdb_stdout, deprecated_selected_frame, 1704 regnum, fpregs); 1705 } 1706 continue; 1707 } 1708 } 1709 1710 /* Nothing matched. */ 1711 error ("Invalid register `%.*s'", (int) (end - start), start); 1712 } 1713} 1714 1715void 1716all_registers_info (char *addr_exp, int from_tty) 1717{ 1718 registers_info (addr_exp, 1); 1719} 1720 1721static void 1722nofp_registers_info (char *addr_exp, int from_tty) 1723{ 1724 registers_info (addr_exp, 0); 1725} 1726 1727static void 1728print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, 1729 struct frame_info *frame, const char *args) 1730{ 1731 if (!target_has_registers) 1732 error ("The program has no registers now."); 1733 if (deprecated_selected_frame == NULL) 1734 error ("No selected frame."); 1735 1736 if (gdbarch_print_vector_info_p (gdbarch)) 1737 gdbarch_print_vector_info (gdbarch, file, frame, args); 1738 else 1739 { 1740 int regnum; 1741 int printed_something = 0; 1742 1743 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) 1744 { 1745 if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup)) 1746 { 1747 printed_something = 1; 1748 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1); 1749 } 1750 } 1751 if (!printed_something) 1752 fprintf_filtered (file, "No vector information\n"); 1753 } 1754} 1755 1756static void 1757vector_info (char *args, int from_tty) 1758{ 1759 print_vector_info (current_gdbarch, gdb_stdout, deprecated_selected_frame, args); 1760} 1761 1762 1763/* 1764 * TODO: 1765 * Should save/restore the tty state since it might be that the 1766 * program to be debugged was started on this tty and it wants 1767 * the tty in some state other than what we want. If it's running 1768 * on another terminal or without a terminal, then saving and 1769 * restoring the tty state is a harmless no-op. 1770 * This only needs to be done if we are attaching to a process. 1771 */ 1772 1773/* 1774 attach_command -- 1775 takes a program started up outside of gdb and ``attaches'' to it. 1776 This stops it cold in its tracks and allows us to start debugging it. 1777 and wait for the trace-trap that results from attaching. */ 1778 1779void 1780attach_command (char *args, int from_tty) 1781{ 1782 char *exec_file; 1783 char *full_exec_path = NULL; 1784 1785 dont_repeat (); /* Not for the faint of heart */ 1786 1787 if (target_has_execution) 1788 { 1789 if (query ("A program is being debugged already. Kill it? ")) 1790 target_kill (); 1791 else 1792 error ("Not killed."); 1793 } 1794 1795 target_attach (args, from_tty); 1796 1797 /* Set up the "saved terminal modes" of the inferior 1798 based on what modes we are starting it with. */ 1799 target_terminal_init (); 1800 1801 /* Install inferior's terminal modes. */ 1802 target_terminal_inferior (); 1803 1804 /* Set up execution context to know that we should return from 1805 wait_for_inferior as soon as the target reports a stop. */ 1806 init_wait_for_inferior (); 1807 clear_proceed_status (); 1808 1809 /* No traps are generated when attaching to inferior under Mach 3 1810 or GNU hurd. */ 1811#ifndef ATTACH_NO_WAIT 1812 /* Careful here. See comments in inferior.h. Basically some OSes 1813 don't ignore SIGSTOPs on continue requests anymore. We need a 1814 way for handle_inferior_event to reset the stop_signal variable 1815 after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for. */ 1816 stop_soon = STOP_QUIETLY_NO_SIGSTOP; 1817 wait_for_inferior (); 1818 stop_soon = NO_STOP_QUIETLY; 1819#endif 1820 1821 /* 1822 * If no exec file is yet known, try to determine it from the 1823 * process itself. 1824 */ 1825 exec_file = (char *) get_exec_file (0); 1826 if (!exec_file) 1827 { 1828 exec_file = target_pid_to_exec_file (PIDGET (inferior_ptid)); 1829 if (exec_file) 1830 { 1831 /* It's possible we don't have a full path, but rather just a 1832 filename. Some targets, such as HP-UX, don't provide the 1833 full path, sigh. 1834 1835 Attempt to qualify the filename against the source path. 1836 (If that fails, we'll just fall back on the original 1837 filename. Not much more we can do...) 1838 */ 1839 if (!source_full_path_of (exec_file, &full_exec_path)) 1840 full_exec_path = savestring (exec_file, strlen (exec_file)); 1841 1842 exec_file_attach (full_exec_path, from_tty); 1843 symbol_file_add_main (full_exec_path, from_tty); 1844 } 1845 } 1846 1847#ifdef SOLIB_ADD 1848 /* Add shared library symbols from the newly attached process, if any. */ 1849 SOLIB_ADD ((char *) 0, from_tty, ¤t_target, auto_solib_add); 1850 re_enable_breakpoints_in_shlibs (); 1851#endif 1852 1853 /* Take any necessary post-attaching actions for this platform. 1854 */ 1855 target_post_attach (PIDGET (inferior_ptid)); 1856 1857 normal_stop (); 1858 1859 if (attach_hook) 1860 attach_hook (); 1861} 1862 1863/* 1864 * detach_command -- 1865 * takes a program previously attached to and detaches it. 1866 * The program resumes execution and will no longer stop 1867 * on signals, etc. We better not have left any breakpoints 1868 * in the program or it'll die when it hits one. For this 1869 * to work, it may be necessary for the process to have been 1870 * previously attached. It *might* work if the program was 1871 * started via the normal ptrace (PTRACE_TRACEME). 1872 */ 1873 1874static void 1875detach_command (char *args, int from_tty) 1876{ 1877 dont_repeat (); /* Not for the faint of heart */ 1878 target_detach (args, from_tty); 1879#if defined(SOLIB_RESTART) 1880 SOLIB_RESTART (); 1881#endif 1882 if (detach_hook) 1883 detach_hook (); 1884} 1885 1886/* Disconnect from the current target without resuming it (leaving it 1887 waiting for a debugger). 1888 1889 We'd better not have left any breakpoints in the program or the 1890 next debugger will get confused. Currently only supported for some 1891 remote targets, since the normal attach mechanisms don't work on 1892 stopped processes on some native platforms (e.g. GNU/Linux). */ 1893 1894static void 1895disconnect_command (char *args, int from_tty) 1896{ 1897 dont_repeat (); /* Not for the faint of heart */ 1898 target_disconnect (args, from_tty); 1899#if defined(SOLIB_RESTART) 1900 SOLIB_RESTART (); 1901#endif 1902 if (detach_hook) 1903 detach_hook (); 1904} 1905 1906/* Stop the execution of the target while running in async mode, in 1907 the backgound. */ 1908void 1909interrupt_target_command (char *args, int from_tty) 1910{ 1911 if (event_loop_p && target_can_async_p ()) 1912 { 1913 dont_repeat (); /* Not for the faint of heart */ 1914 target_stop (); 1915 } 1916} 1917 1918static void 1919print_float_info (struct gdbarch *gdbarch, struct ui_file *file, 1920 struct frame_info *frame, const char *args) 1921{ 1922 if (!target_has_registers) 1923 error ("The program has no registers now."); 1924 if (deprecated_selected_frame == NULL) 1925 error ("No selected frame."); 1926 1927 if (gdbarch_print_float_info_p (gdbarch)) 1928 gdbarch_print_float_info (gdbarch, file, frame, args); 1929 else 1930 { 1931 int regnum; 1932 int printed_something = 0; 1933 1934 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++) 1935 { 1936 if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup)) 1937 { 1938 printed_something = 1; 1939 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1); 1940 } 1941 } 1942 if (!printed_something) 1943 fprintf_filtered (file, "\ 1944No floating-point info available for this processor.\n"); 1945 } 1946} 1947 1948static void 1949float_info (char *args, int from_tty) 1950{ 1951 print_float_info (current_gdbarch, gdb_stdout, deprecated_selected_frame, args); 1952} 1953 1954static void 1955unset_command (char *args, int from_tty) 1956{ 1957 printf_filtered ("\"unset\" must be followed by the name of "); 1958 printf_filtered ("an unset subcommand.\n"); 1959 help_list (unsetlist, "unset ", -1, gdb_stdout); 1960} 1961 1962void 1963_initialize_infcmd (void) 1964{ 1965 struct cmd_list_element *c; 1966 1967 c = add_com ("tty", class_run, tty_command, 1968 "Set terminal for future runs of program being debugged."); 1969 set_cmd_completer (c, filename_completer); 1970 1971 c = add_set_cmd ("args", class_run, var_string_noescape, 1972 (char *) &inferior_args, 1973 "Set argument list to give program being debugged when it is started.\n\ 1974Follow this command with any number of args, to be passed to the program.", 1975 &setlist); 1976 set_cmd_completer (c, filename_completer); 1977 set_cmd_sfunc (c, notice_args_set); 1978 c = add_show_from_set (c, &showlist); 1979 set_cmd_sfunc (c, notice_args_read); 1980 1981 c = add_cmd 1982 ("environment", no_class, environment_info, 1983 "The environment to give the program, or one variable's value.\n\ 1984With an argument VAR, prints the value of environment variable VAR to\n\ 1985give the program being debugged. With no arguments, prints the entire\n\ 1986environment to be given to the program.", &showlist); 1987 set_cmd_completer (c, noop_completer); 1988 1989 add_prefix_cmd ("unset", no_class, unset_command, 1990 "Complement to certain \"set\" commands.", 1991 &unsetlist, "unset ", 0, &cmdlist); 1992 1993 c = add_cmd ("environment", class_run, unset_environment_command, 1994 "Cancel environment variable VAR for the program.\n\ 1995This does not affect the program until the next \"run\" command.", 1996 &unsetlist); 1997 set_cmd_completer (c, noop_completer); 1998 1999 c = add_cmd ("environment", class_run, set_environment_command, 2000 "Set environment variable value to give the program.\n\ 2001Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\ 2002VALUES of environment variables are uninterpreted strings.\n\ 2003This does not affect the program until the next \"run\" command.", 2004 &setlist); 2005 set_cmd_completer (c, noop_completer); 2006 2007 c = add_com ("path", class_files, path_command, 2008 "Add directory DIR(s) to beginning of search path for object files.\n\ 2009$cwd in the path means the current working directory.\n\ 2010This path is equivalent to the $PATH shell variable. It is a list of\n\ 2011directories, separated by colons. These directories are searched to find\n\ 2012fully linked executable files and separately compiled object files as needed."); 2013 set_cmd_completer (c, filename_completer); 2014 2015 c = add_cmd ("paths", no_class, path_info, 2016 "Current search path for finding object files.\n\ 2017$cwd in the path means the current working directory.\n\ 2018This path is equivalent to the $PATH shell variable. It is a list of\n\ 2019directories, separated by colons. These directories are searched to find\n\ 2020fully linked executable files and separately compiled object files as needed.", 2021 &showlist); 2022 set_cmd_completer (c, noop_completer); 2023 2024 add_com ("attach", class_run, attach_command, 2025 "Attach to a process or file outside of GDB.\n\ 2026This command attaches to another target, of the same type as your last\n\ 2027\"target\" command (\"info files\" will show your target stack).\n\ 2028The command may take as argument a process id or a device file.\n\ 2029For a process id, you must have permission to send the process a signal,\n\ 2030and it must have the same effective uid as the debugger.\n\ 2031When using \"attach\" with a process id, the debugger finds the\n\ 2032program running in the process, looking first in the current working\n\ 2033directory, or (if not found there) using the source file search path\n\ 2034(see the \"directory\" command). You can also use the \"file\" command\n\ 2035to specify the program, and to load its symbol table."); 2036 2037 add_com ("detach", class_run, detach_command, 2038 "Detach a process or file previously attached.\n\ 2039If a process, it is no longer traced, and it continues its execution. If\n\ 2040you were debugging a file, the file is closed and gdb no longer accesses it."); 2041 2042 add_com ("disconnect", class_run, disconnect_command, 2043 "Disconnect from a target.\n\ 2044The target will wait for another debugger to connect. Not available for\n\ 2045all targets."); 2046 2047 add_com ("signal", class_run, signal_command, 2048 "Continue program giving it signal specified by the argument.\n\ 2049An argument of \"0\" means continue program without giving it a signal."); 2050 2051 add_com ("stepi", class_run, stepi_command, 2052 "Step one instruction exactly.\n\ 2053Argument N means do this N times (or till program stops for another reason)."); 2054 add_com_alias ("si", "stepi", class_alias, 0); 2055 2056 add_com ("nexti", class_run, nexti_command, 2057 "Step one instruction, but proceed through subroutine calls.\n\ 2058Argument N means do this N times (or till program stops for another reason)."); 2059 add_com_alias ("ni", "nexti", class_alias, 0); 2060 2061 add_com ("finish", class_run, finish_command, 2062 "Execute until selected stack frame returns.\n\ 2063Upon return, the value returned is printed and put in the value history."); 2064 2065 add_com ("next", class_run, next_command, 2066 "Step program, proceeding through subroutine calls.\n\ 2067Like the \"step\" command as long as subroutine calls do not happen;\n\ 2068when they do, the call is treated as one instruction.\n\ 2069Argument N means do this N times (or till program stops for another reason)."); 2070 add_com_alias ("n", "next", class_run, 1); 2071 if (xdb_commands) 2072 add_com_alias ("S", "next", class_run, 1); 2073 2074 add_com ("step", class_run, step_command, 2075 "Step program until it reaches a different source line.\n\ 2076Argument N means do this N times (or till program stops for another reason)."); 2077 add_com_alias ("s", "step", class_run, 1); 2078 2079 c = add_com ("until", class_run, until_command, 2080 "Execute until the program reaches a source line greater than the current\n\ 2081or a specified location (same args as break command) within the current frame."); 2082 set_cmd_completer (c, location_completer); 2083 add_com_alias ("u", "until", class_run, 1); 2084 2085 c = add_com ("advance", class_run, advance_command, 2086 "Continue the program up to the given location (same form as args for break command).\n\ 2087Execution will also stop upon exit from the current stack frame."); 2088 set_cmd_completer (c, location_completer); 2089 2090 c = add_com ("jump", class_run, jump_command, 2091 "Continue program being debugged at specified line or address.\n\ 2092Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\ 2093for an address to start at."); 2094 set_cmd_completer (c, location_completer); 2095 2096 if (xdb_commands) 2097 { 2098 c = add_com ("go", class_run, go_command, 2099 "Usage: go <location>\n\ 2100Continue program being debugged, stopping at specified line or \n\ 2101address.\n\ 2102Give as argument either LINENUM or *ADDR, where ADDR is an \n\ 2103expression for an address to start at.\n\ 2104This command is a combination of tbreak and jump."); 2105 set_cmd_completer (c, location_completer); 2106 } 2107 2108 if (xdb_commands) 2109 add_com_alias ("g", "go", class_run, 1); 2110 2111 add_com ("continue", class_run, continue_command, 2112 "Continue program being debugged, after signal or breakpoint.\n\ 2113If proceeding from breakpoint, a number N may be used as an argument,\n\ 2114which means to set the ignore count of that breakpoint to N - 1 (so that\n\ 2115the breakpoint won't break until the Nth time it is reached)."); 2116 add_com_alias ("c", "cont", class_run, 1); 2117 add_com_alias ("fg", "cont", class_run, 1); 2118 2119 c = add_com ("run", class_run, run_command, 2120 "Start debugged program. You may specify arguments to give it.\n\ 2121Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\ 2122Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\ 2123With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\ 2124To cancel previous arguments and run with no arguments,\n\ 2125use \"set args\" without arguments."); 2126 set_cmd_completer (c, filename_completer); 2127 add_com_alias ("r", "run", class_run, 1); 2128 if (xdb_commands) 2129 add_com ("R", class_run, run_no_args_command, 2130 "Start debugged program with no arguments."); 2131 2132 add_com ("interrupt", class_run, interrupt_target_command, 2133 "Interrupt the execution of the debugged program."); 2134 2135 add_info ("registers", nofp_registers_info, 2136 "List of integer registers and their contents, for selected stack frame.\n\ 2137Register name as argument means describe only that register."); 2138 add_info_alias ("r", "registers", 1); 2139 2140 if (xdb_commands) 2141 add_com ("lr", class_info, nofp_registers_info, 2142 "List of integer registers and their contents, for selected stack frame.\n\ 2143 Register name as argument means describe only that register."); 2144 add_info ("all-registers", all_registers_info, 2145 "List of all registers and their contents, for selected stack frame.\n\ 2146Register name as argument means describe only that register."); 2147 2148 add_info ("program", program_info, 2149 "Execution status of the program."); 2150 2151 add_info ("float", float_info, 2152 "Print the status of the floating point unit\n"); 2153 2154 add_info ("vector", vector_info, 2155 "Print the status of the vector unit\n"); 2156 2157 inferior_environ = make_environ (); 2158 init_environ (inferior_environ); 2159} 2160