1 /* Memory-access and commands for "inferior" (child) process, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #include <sys/param.h>
34 extern char *sys_siglist
[];
36 extern void until_break_command (); /* breakpoint.c */
38 #define ERROR_NO_INFERIOR \
39 if (!target_has_execution) error ("The program is not being run.");
41 /* String containing arguments to give to the program, separated by spaces.
42 Empty string (pointer to '\0') means no args. */
44 static char *inferior_args
;
46 /* File name for default use for standard in/out in the inferior. */
48 char *inferior_io_terminal
;
50 /* Pid of our debugged inferior, or 0 if no inferior now.
51 Since various parts of infrun.c test this to see whether there is a program
52 being debugged it should be nonzero (currently 3 is used) for remote
57 /* Last signal that the inferior received (why it stopped). */
61 /* Address at which inferior stopped. */
65 /* Stack frame when program stopped. */
67 FRAME_ADDR stop_frame_address
;
69 /* Chain containing status of breakpoint(s) that we have stopped at. */
73 /* Flag indicating that a command has proceeded the inferior past the
74 current breakpoint. */
76 int breakpoint_proceeded
;
78 /* Nonzero if stopped due to a step command. */
82 /* Nonzero if stopped due to completion of a stack dummy routine. */
86 /* Nonzero if stopped due to a random (unexpected) signal in inferior
89 int stopped_by_random_signal
;
91 /* Range to single step within.
92 If this is nonzero, respond to a single-step signal
93 by continuing to step if the pc is in this range. */
95 CORE_ADDR step_range_start
; /* Inclusive */
96 CORE_ADDR step_range_end
; /* Exclusive */
98 /* Stack frame address as of when stepping command was issued.
99 This is how we know when we step into a subroutine call,
100 and how to set the frame for the breakpoint used to step out. */
102 FRAME_ADDR step_frame_address
;
104 /* 1 means step over all subroutine calls.
105 -1 means step over calls to undebuggable functions. */
109 /* If stepping, nonzero means step count is > 1
110 so don't print frame next time inferior stops
111 if it stops due to stepping. */
115 /* Environment to use for running inferior,
116 in format described in environ.h. */
118 struct environ
*inferior_environ
;
120 CORE_ADDR
read_pc ();
121 void breakpoint_clear_ignore_counts ();
126 tty_command (file
, from_tty
)
131 error_no_arg ("terminal name for running target process");
133 inferior_io_terminal
= savestring (file
, strlen (file
));
137 run_command (args
, from_tty
)
148 !query ("The program being debugged has been started already.\n\
149 Start it from the beginning? "))
150 error ("Program not restarted.");
154 exec_file
= (char *) get_exec_file (0);
156 /* The exec file is re-read every time we do an inferior_died, so
157 we just have to worry about the symbol file. */
163 cmd
= concat ("set args ", args
, NULL
);
164 make_cleanup (free
, cmd
);
165 execute_command (cmd
, from_tty
);
170 printf ("Starting program: %s %s\n",
171 exec_file
? exec_file
: "", inferior_args
);
175 target_create_inferior (exec_file
, inferior_args
,
176 environ_vector (inferior_environ
));
180 continue_command (proc_count_exp
, from_tty
)
181 char *proc_count_exp
;
186 /* If have argument, set proceed count of breakpoint we stopped at. */
188 if (proc_count_exp
!= NULL
)
190 bpstat bs
= stop_bpstat
;
191 int num
= bpstat_num (&bs
);
192 if (num
== 0 && from_tty
)
195 ("Not stopped at any breakpoint; argument ignored.\n");
199 set_ignore_count (num
,
200 parse_and_eval_address (proc_count_exp
) - 1,
202 /* set_ignore_count prints a message ending with a period.
203 So print two spaces before "Continuing.". */
206 num
= bpstat_num (&bs
);
211 printf ("Continuing.\n");
213 clear_proceed_status ();
215 proceed ((CORE_ADDR
) -1, -1, 0);
218 /* Step until outside of current statement. */
219 static void step_1 ();
223 step_command (count_string
, from_tty
)
227 step_1 (0, 0, count_string
);
230 /* Likewise, but skip over subroutine calls as if single instructions. */
234 next_command (count_string
, from_tty
)
238 step_1 (1, 0, count_string
);
241 /* Likewise, but step only one instruction. */
245 stepi_command (count_string
, from_tty
)
249 step_1 (0, 1, count_string
);
254 nexti_command (count_string
, from_tty
)
258 step_1 (1, 1, count_string
);
262 step_1 (skip_subroutines
, single_inst
, count_string
)
263 int skip_subroutines
;
267 register int count
= 1;
271 count
= count_string
? parse_and_eval_address (count_string
) : 1;
273 for (; count
> 0; count
--)
275 clear_proceed_status ();
278 fr
= get_current_frame ();
279 if (!fr
) /* Avoid coredump here. Why tho? */
280 error ("No current frame");
281 step_frame_address
= FRAME_FP (fr
);
285 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
286 if (step_range_end
== 0)
290 misc
= find_pc_misc_function (stop_pc
);
291 target_terminal_ours ();
292 printf ("Current function has no line number information.\n");
295 /* No info or after _etext ("Can't happen") */
296 if (misc
== -1 || misc
== misc_function_count
- 1)
297 error ("No data available on pc function.");
299 printf ("Single stepping until function exit.\n");
302 step_range_start
= misc_function_vector
[misc
].address
;
303 step_range_end
= misc_function_vector
[misc
+ 1].address
;
308 /* Say we are stepping, but stop after one insn whatever it does.
309 Don't step through subroutine calls even to undebuggable
311 step_range_start
= step_range_end
= 1;
312 if (!skip_subroutines
)
316 if (skip_subroutines
)
319 step_multi
= (count
> 1);
320 proceed ((CORE_ADDR
) -1, -1, 1);
323 #if defined (SHIFT_INST_REGS)
324 write_register (NNPC_REGNUM
, read_register (NPC_REGNUM
));
325 write_register (NPC_REGNUM
, read_register (PC_REGNUM
));
330 /* Continue program at specified address. */
333 jump_command (arg
, from_tty
)
337 register CORE_ADDR addr
;
338 struct symtabs_and_lines sals
;
339 struct symtab_and_line sal
;
344 error_no_arg ("starting address");
346 sals
= decode_line_spec_1 (arg
, 1);
349 error ("Unreasonable jump request");
355 if (sal
.symtab
== 0 && sal
.pc
== 0)
356 error ("No source file has been specified.");
358 resolve_sal_pc (&sal
); /* May error out */
361 struct symbol
*fn
= get_frame_function (get_current_frame ());
362 struct symbol
*sfn
= find_pc_function (sal
.pc
);
363 if (fn
!= 0 && sfn
!= fn
364 && ! query ("Line %d is not in `%s'. Jump anyway? ",
365 sal
.line
, SYMBOL_NAME (fn
)))
366 error ("Not confirmed.");
369 addr
= ADDR_BITS_SET (sal
.pc
);
372 printf ("Continuing at %s.\n", local_hex_string(addr
));
374 clear_proceed_status ();
375 proceed (addr
, 0, 0);
378 /* Continue program giving it specified signal. */
381 signal_command (signum_exp
, from_tty
)
387 dont_repeat (); /* Too dangerous. */
391 error_no_arg ("signal number");
393 signum
= parse_and_eval_address (signum_exp
);
396 printf ("Continuing with signal %d.\n", signum
);
398 clear_proceed_status ();
399 proceed (stop_pc
, signum
, 0);
402 /* Execute a "stack dummy", a piece of code stored in the stack
403 by the debugger to be executed in the inferior.
405 To call: first, do PUSH_DUMMY_FRAME.
406 Then push the contents of the dummy. It should end with a breakpoint insn.
407 Then call here, passing address at which to start the dummy.
409 The contents of all registers are saved before the dummy frame is popped
410 and copied into the buffer BUFFER.
412 The dummy's frame is automatically popped whenever that break is hit.
413 If that is the first time the program stops, run_stack_dummy
414 returns to its caller with that frame already gone.
415 Otherwise, the caller never gets returned to. */
417 /* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
419 static int stack_dummy_testing
= 0;
422 run_stack_dummy (addr
, buffer
)
424 char buffer
[REGISTER_BYTES
];
426 /* Now proceed, having reached the desired place. */
427 clear_proceed_status ();
428 if (stack_dummy_testing
& 4)
433 proceed_to_finish
= 1; /* We want stop_registers, please... */
434 proceed (addr
, 0, 0);
436 if (!stop_stack_dummy
)
438 "Cannot continue previously requested operation". */
440 The program being debugged stopped while in a function called from GDB.\n\
441 The expression which contained the function call has been discarded.");
443 /* On return, the stack dummy has been popped already. */
445 bcopy (stop_registers
, buffer
, sizeof stop_registers
);
448 /* Proceed until we reach a different source line with pc greater than
449 our current one or exit the function. We skip calls in both cases.
451 Note that eventually this command should probably be changed so
452 that only source lines are printed out when we hit the breakpoint
453 we set. I'm going to postpone this until after a hopeful rewrite
454 of wait_for_inferior and the proceed status code. -- randy */
458 until_next_command (from_tty
)
464 struct symtab_and_line sal
;
466 clear_proceed_status ();
468 frame
= get_current_frame ();
470 /* Step until either exited from this function or greater
471 than the current line (if in symbolic section) or pc (if
475 func
= find_pc_function (pc
);
479 int misc_func
= find_pc_misc_function (pc
);
482 error ("Execution is not within a known function.");
484 step_range_start
= misc_function_vector
[misc_func
].address
;
489 sal
= find_pc_line (pc
, 0);
491 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
492 step_range_end
= sal
.end
;
496 step_frame_address
= FRAME_FP (frame
);
498 step_multi
= 0; /* Only one call to proceed */
500 proceed ((CORE_ADDR
) -1, -1, 1);
504 until_command (arg
, from_tty
)
508 if (!target_has_execution
)
509 error ("The program is not running.");
511 until_break_command (arg
, from_tty
);
513 until_next_command (from_tty
);
516 /* "finish": Set a temporary breakpoint at the place
517 the selected frame will return to, then continue. */
520 finish_command (arg
, from_tty
)
524 struct symtab_and_line sal
;
525 register FRAME frame
;
526 struct frame_info
*fi
;
527 register struct symbol
*function
;
530 error ("The \"finish\" command does not take any arguments.");
531 if (!target_has_execution
)
532 error ("The program is not running.");
533 if (selected_frame
== NULL
)
534 error ("No selected frame.");
536 frame
= get_prev_frame (selected_frame
);
538 error ("\"finish\" not meaningful in the outermost frame.");
540 clear_proceed_status ();
542 fi
= get_frame_info (frame
);
543 sal
= find_pc_line (fi
->pc
, 0);
545 set_momentary_breakpoint (sal
, frame
);
547 /* Find the function we will return from. */
549 fi
= get_frame_info (selected_frame
);
550 function
= find_pc_function (fi
->pc
);
552 /* Print info on the selected frame, including level number
556 printf_filtered ("Run till exit from ");
557 print_stack_frame (selected_frame
, selected_frame_level
, 0);
560 proceed_to_finish
= 1; /* We want stop_registers, please... */
561 proceed ((CORE_ADDR
) -1, -1, 0);
563 if (bpstat_momentary_breakpoint (stop_bpstat
) && function
!= 0)
565 struct type
*value_type
;
569 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
571 fatal ("internal: finish_command: function has no target type");
573 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
576 funcaddr
= BLOCK_START (SYMBOL_BLOCK_VALUE (function
));
578 val
= value_being_returned (value_type
, stop_registers
,
579 using_struct_return (value_of_variable (function
),
582 BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function
))));
584 printf_filtered ("Value returned is $%d = ", record_latest_value (val
));
585 value_print (val
, stdout
, 0, Val_no_prettyprint
);
586 printf_filtered ("\n");
592 program_info (args
, from_tty
)
596 bpstat bs
= stop_bpstat
;
597 int num
= bpstat_num (&bs
);
599 if (!target_has_execution
)
601 printf ("The program being debugged is not being run.\n");
605 target_files_info ();
606 printf ("Program stopped at %s.\n", local_hex_string(stop_pc
));
608 printf ("It stopped after being stepped.\n");
611 /* There may be several breakpoints in the same place, so this
612 isn't as strange as it seems. */
616 printf ("It stopped at a breakpoint that has since been deleted.\n");
618 printf ("It stopped at breakpoint %d.\n", num
);
619 num
= bpstat_num (&bs
);
622 else if (stop_signal
) {
623 #ifdef PRINT_RANDOM_SIGNAL
624 PRINT_RANDOM_SIGNAL (stop_signal
);
626 printf ("It stopped with signal %d (%s).\n",
628 (stop_signal
> NSIG
)? "unknown": sys_siglist
[stop_signal
]);
633 printf ("Type \"info stack\" or \"info registers\" for more information.\n");
637 environment_info (var
)
642 register char *val
= get_in_environ (inferior_environ
, var
);
644 printf ("%s = %s\n", var
, val
);
646 printf ("Environment variable \"%s\" not defined.\n", var
);
650 register char **vector
= environ_vector (inferior_environ
);
652 printf ("%s\n", *vector
++);
657 set_environment_command (arg
)
660 register char *p
, *val
, *var
;
664 error_no_arg ("environment variable and value");
666 /* Find seperation between variable name and value */
667 p
= (char *) strchr (arg
, '=');
668 val
= (char *) strchr (arg
, ' ');
670 if (p
!= 0 && val
!= 0)
672 /* We have both a space and an equals. If the space is before the
673 equals and the only thing between the two is more space, use
679 /* Take the smaller of the two. If there was space before the
680 "=", they will be the same right now. */
681 p
= arg
+ min (p
- arg
, val
- arg
);
683 else if (val
!= 0 && p
== 0)
687 error_no_arg ("environment variable to set");
689 if (p
== 0 || p
[1] == 0)
693 p
= arg
+ strlen (arg
); /* So that savestring below will work */
697 /* Not setting variable value to null */
699 while (*val
== ' ' || *val
== '\t')
703 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t')) p
--;
705 var
= savestring (arg
, p
- arg
);
708 printf ("Setting environment variable \"%s\" to null value.\n", var
);
709 set_in_environ (inferior_environ
, var
, "");
712 set_in_environ (inferior_environ
, var
, val
);
717 unset_environment_command (var
, from_tty
)
723 /* If there is no argument, delete all environment variables.
724 Ask for confirmation if reading from the terminal. */
725 if (!from_tty
|| query ("Delete all environment variables? "))
727 free_environ (inferior_environ
);
728 inferior_environ
= make_environ ();
732 unset_in_environ (inferior_environ
, var
);
735 /* Handle the execution path (PATH variable) */
737 const static char path_var_name
[] = "PATH";
741 path_info (args
, from_tty
)
745 printf ("Executable and object file path: %s\n",
746 get_in_environ (inferior_environ
, path_var_name
));
749 /* Add zero or more directories to the front of the execution path. */
752 path_command (dirname
, from_tty
)
759 exec_path
= strsave (get_in_environ (inferior_environ
, path_var_name
));
760 mod_path (dirname
, &exec_path
);
761 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
764 path_info ((char *)NULL
, from_tty
);
770 return ADDR_BITS_REMOVE ((CORE_ADDR
) read_register (PC_REGNUM
));
777 write_register (PC_REGNUM
, (long) val
);
779 write_register (NPC_REGNUM
, (long) val
+4);
784 char *reg_names
[] = REGISTER_NAMES
;
786 /* Print out the machine register regnum. If regnum is -1,
787 print all registers (fpregs == 1) or all non-float registers
790 For most machines, having all_registers_info() print the
791 register(s) one per line is good enough. If a different format
792 is required, (eg, for MIPS or Pyramid 90x, which both have
793 lots of regs), or there is an existing convention for showing
794 all the registers, define the macro DO_REGISTERS_INFO(regnum, fp)
795 to provide that format. */
797 #if !defined (DO_REGISTERS_INFO)
798 #define DO_REGISTERS_INFO(regnum, fp) do_registers_info(regnum, fp)
800 do_registers_info (regnum
, fpregs
)
806 for (i
= 0; i
< NUM_REGS
; i
++)
808 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
809 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
811 /* Decide between printing all regs, nonfloat regs, or specific reg. */
813 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
&& !fpregs
)
820 fputs_filtered (reg_names
[i
], stdout
);
821 print_spaces_filtered (15 - strlen (reg_names
[i
]), stdout
);
823 /* Get the data in raw format, then convert also to virtual format. */
824 if (read_relative_register_raw_bytes (i
, raw_buffer
))
826 printf_filtered ("Invalid register contents\n");
830 target_convert_to_virtual (i
, raw_buffer
, virtual_buffer
);
832 /* If virtual format is floating, print it that way, and in raw hex. */
833 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
834 && ! INVALID_FLOAT (virtual_buffer
, REGISTER_VIRTUAL_SIZE (i
)))
838 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0,
839 stdout
, 0, 1, 0, Val_pretty_default
);
841 printf_filtered ("\t(raw 0x");
842 for (j
= 0; j
< REGISTER_RAW_SIZE (i
); j
++)
843 printf_filtered ("%02x", (unsigned char)raw_buffer
[j
]);
844 printf_filtered (")");
847 /* FIXME! val_print probably can handle all of these cases now... */
849 /* Else if virtual format is too long for printf,
850 print in hex a byte at a time. */
851 else if (REGISTER_VIRTUAL_SIZE (i
) > sizeof (long))
854 printf_filtered ("0x");
855 for (j
= 0; j
< REGISTER_VIRTUAL_SIZE (i
); j
++)
856 printf_filtered ("%02x", (unsigned char)virtual_buffer
[j
]);
858 /* Else print as integer in hex and in decimal. */
861 val_print (REGISTER_VIRTUAL_TYPE (i
), raw_buffer
, 0,
862 stdout
, 'x', 1, 0, Val_pretty_default
);
863 printf_filtered ("\t");
864 val_print (REGISTER_VIRTUAL_TYPE (i
), raw_buffer
, 0,
865 stdout
, 0, 1, 0, Val_pretty_default
);
868 /* The SPARC wants to print even-numbered float regs as doubles
869 in addition to printing them as floats. */
870 #ifdef PRINT_REGISTER_HOOK
871 PRINT_REGISTER_HOOK (i
);
874 printf_filtered ("\n");
877 #endif /* no DO_REGISTERS_INFO. */
880 registers_info (addr_exp
, fpregs
)
886 if (!target_has_registers
)
887 error ("The program has no registers now.");
891 if (*addr_exp
>= '0' && *addr_exp
<= '9')
892 regnum
= atoi (addr_exp
);
895 register char *p
= addr_exp
;
898 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
899 if (!strcmp (p
, reg_names
[regnum
]))
901 if (regnum
== NUM_REGS
)
902 error ("%s: invalid register name.", addr_exp
);
908 DO_REGISTERS_INFO(regnum
, fpregs
);
912 all_registers_info (addr_exp
)
915 registers_info (addr_exp
, 1);
919 nofp_registers_info (addr_exp
)
922 registers_info (addr_exp
, 0);
927 * Should save/restore the tty state since it might be that the
928 * program to be debugged was started on this tty and it wants
929 * the tty in some state other than what we want. If it's running
930 * on another terminal or without a terminal, then saving and
931 * restoring the tty state is a harmless no-op.
932 * This only needs to be done if we are attaching to a process.
937 * takes a program started up outside of gdb and ``attaches'' to it.
938 * This stops it cold in its tracks and allows us to start tracing it.
939 * For this to work, we must be able to send the process a
940 * signal and we must have the same effective uid as the program.
943 attach_command (args
, from_tty
)
947 dont_repeat (); /* Not for the faint of heart */
948 target_attach (args
, from_tty
);
953 * takes a program previously attached to and detaches it.
954 * The program resumes execution and will no longer stop
955 * on signals, etc. We better not have left any breakpoints
956 * in the program or it'll die when it hits one. For this
957 * to work, it may be necessary for the process to have been
958 * previously attached. It *might* work if the program was
959 * started via the normal ptrace (PTRACE_TRACEME).
963 detach_command (args
, from_tty
)
967 dont_repeat (); /* Not for the faint of heart */
968 target_detach (args
, from_tty
);
973 float_info (addr_exp
)
979 printf ("No floating point info available for this processor.\n");
983 struct cmd_list_element
*unsetlist
= NULL
;
987 unset_command (args
, from_tty
)
991 printf ("\"unset\" must be followed by the name of an unset subcommand.\n");
992 help_list (unsetlist
, "unset ", -1, stdout
);
996 _initialize_infcmd ()
998 struct cmd_list_element
*c
;
1000 add_com ("tty", class_run
, tty_command
,
1001 "Set terminal for future runs of program being debugged.");
1004 (add_set_cmd ("args", class_run
, var_string_noescape
, (char *)&inferior_args
,
1006 "Set arguments to give program being debugged when it is started.\n\
1007 Follow this command with any number of args, to be passed to the program.",
1012 ("environment", no_class
, environment_info
,
1013 "The environment to give the program, or one variable's value.\n\
1014 With an argument VAR, prints the value of environment variable VAR to\n\
1015 give the program being debugged. With no arguments, prints the entire\n\
1016 environment to be given to the program.", &showlist
);
1017 c
->completer
= noop_completer
;
1019 add_prefix_cmd ("unset", no_class
, unset_command
,
1020 "Complement to certain \"set\" commands",
1021 &unsetlist
, "unset ", 0, &cmdlist
);
1023 c
= add_cmd ("environment", class_run
, unset_environment_command
,
1024 "Cancel environment variable VAR for the program.\n\
1025 This does not affect the program until the next \"run\" command.",
1027 c
->completer
= noop_completer
;
1029 c
= add_cmd ("environment", class_run
, set_environment_command
,
1030 "Set environment variable value to give the program.\n\
1031 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
1032 VALUES of environment variables are uninterpreted strings.\n\
1033 This does not affect the program until the next \"run\" command.",
1035 c
->completer
= noop_completer
;
1037 add_com ("path", class_files
, path_command
,
1038 "Add directory DIR(s) to beginning of search path for object files.\n\
1039 $cwd in the path means the current working directory.\n\
1040 This path is equivalent to the $PATH shell variable. It is a list of\n\
1041 directories, separated by colons. These directories are searched to find\n\
1042 fully linked executable files and separately compiled object files as needed.");
1044 c
= add_cmd ("paths", no_class
, path_info
,
1045 "Current search path for finding object files.\n\
1046 $cwd in the path means the current working directory.\n\
1047 This path is equivalent to the $PATH shell variable. It is a list of\n\
1048 directories, separated by colons. These directories are searched to find\n\
1049 fully linked executable files and separately compiled object files as needed.", &showlist
);
1050 c
->completer
= noop_completer
;
1052 add_com ("attach", class_run
, attach_command
,
1053 "Attach to a process or file outside of GDB.\n\
1054 This command attaches to another target, of the same type as your last\n\
1055 `target' command (`info files' will show your target stack).\n\
1056 The command may take as argument a process id or a device file.\n\
1057 For a process id, you must have permission to send the process a signal,\n\
1058 and it must have the same effective uid as the debugger.\n\
1059 When using \"attach\", you should use the \"file\" command to specify\n\
1060 the program running in the process, and to load its symbol table.");
1062 add_com ("detach", class_run
, detach_command
,
1063 "Detach a process or file previously attached.\n\
1064 If a process, it is no longer traced, and it continues its execution. If you\n\
1065 were debugging a file, the file is closed and gdb no longer accesses it.");
1067 add_com ("signal", class_run
, signal_command
,
1068 "Continue program giving it signal number SIGNUMBER.");
1070 add_com ("stepi", class_run
, stepi_command
,
1071 "Step one instruction exactly.\n\
1072 Argument N means do this N times (or till program stops for another reason).");
1073 add_com_alias ("si", "stepi", class_alias
, 0);
1075 add_com ("nexti", class_run
, nexti_command
,
1076 "Step one instruction, but proceed through subroutine calls.\n\
1077 Argument N means do this N times (or till program stops for another reason).");
1078 add_com_alias ("ni", "nexti", class_alias
, 0);
1080 add_com ("finish", class_run
, finish_command
,
1081 "Execute until selected stack frame returns.\n\
1082 Upon return, the value returned is printed and put in the value history.");
1084 add_com ("next", class_run
, next_command
,
1085 "Step program, proceeding through subroutine calls.\n\
1086 Like the \"step\" command as long as subroutine calls do not happen;\n\
1087 when they do, the call is treated as one instruction.\n\
1088 Argument N means do this N times (or till program stops for another reason).");
1089 add_com_alias ("n", "next", class_run
, 1);
1091 add_com ("step", class_run
, step_command
,
1092 "Step program until it reaches a different source line.\n\
1093 Argument N means do this N times (or till program stops for another reason).");
1094 add_com_alias ("s", "step", class_run
, 1);
1096 add_com ("until", class_run
, until_command
,
1097 "Execute until the program reaches a source line greater than the current\n\
1098 or a specified line or address or function (same args as break command).\n\
1099 Execution will also stop upon exit from the current stack frame.");
1100 add_com_alias ("u", "until", class_run
, 1);
1102 add_com ("jump", class_run
, jump_command
,
1103 "Continue program being debugged at specified line or address.\n\
1104 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
1105 for an address to start at.");
1107 add_com ("continue", class_run
, continue_command
,
1108 "Continue program being debugged, after signal or breakpoint.\n\
1109 If proceeding from breakpoint, a number N may be used as an argument:\n\
1110 then the same breakpoint won't break until the Nth time it is reached.");
1111 add_com_alias ("c", "cont", class_run
, 1);
1112 add_com_alias ("fg", "cont", class_run
, 1);
1114 add_com ("run", class_run
, run_command
,
1115 "Start debugged program. You may specify arguments to give it.\n\
1116 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
1117 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
1118 With no arguments, uses arguments last specified (with \"run\" or \"set args\".\n\
1119 To cancel previous arguments and run with no arguments,\n\
1120 use \"set args\" without arguments.");
1121 add_com_alias ("r", "run", class_run
, 1);
1123 add_info ("registers", nofp_registers_info
,
1124 "List of integer registers and their contents, for selected stack frame.\n\
1125 Register name as argument means describe only that register.");
1127 add_info ("all-registers", all_registers_info
,
1128 "List of all registers and their contents, for selected stack frame.\n\
1129 Register name as argument means describe only that register.");
1131 add_info ("program", program_info
,
1132 "Execution status of the program.");
1134 add_info ("float", float_info
,
1135 "Print the status of the floating point unit\n");
1137 inferior_args
= savestring ("", 1); /* Initially no args */
1138 inferior_environ
= make_environ ();
1139 init_environ (inferior_environ
);