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>
35 continue_command
PARAMS ((char *, int));
38 until_next_command
PARAMS ((int));
41 until_command
PARAMS ((char *, int));
44 path_info
PARAMS ((char *, int));
47 path_command
PARAMS ((char *, int));
50 unset_command
PARAMS ((char *, int));
53 float_info
PARAMS ((char *, int));
56 detach_command
PARAMS ((char *, int));
59 nofp_registers_info
PARAMS ((char *, int));
62 all_registers_info
PARAMS ((char *, int));
65 registers_info
PARAMS ((char *, int));
68 do_registers_info
PARAMS ((int, int));
71 unset_environment_command
PARAMS ((char *, int));
74 set_environment_command
PARAMS ((char *, int));
77 environment_info
PARAMS ((char *, int));
80 program_info
PARAMS ((char *, int));
83 finish_command
PARAMS ((char *, int));
86 signal_command
PARAMS ((char *, int));
89 jump_command
PARAMS ((char *, int));
92 step_1
PARAMS ((int, int, char *));
95 nexti_command
PARAMS ((char *, int));
98 stepi_command
PARAMS ((char *, int));
101 next_command
PARAMS ((char *, int));
104 step_command
PARAMS ((char *, int));
107 run_command
PARAMS ((char *, int));
109 #define ERROR_NO_INFERIOR \
110 if (!target_has_execution) error ("The program is not being run.");
112 /* String containing arguments to give to the program, separated by spaces.
113 Empty string (pointer to '\0') means no args. */
115 static char *inferior_args
;
117 /* File name for default use for standard in/out in the inferior. */
119 char *inferior_io_terminal
;
121 /* Pid of our debugged inferior, or 0 if no inferior now.
122 Since various parts of infrun.c test this to see whether there is a program
123 being debugged it should be nonzero (currently 3 is used) for remote
128 /* Last signal that the inferior received (why it stopped). */
132 /* Address at which inferior stopped. */
136 /* Stack frame when program stopped. */
138 FRAME_ADDR stop_frame_address
;
140 /* Chain containing status of breakpoint(s) that we have stopped at. */
144 /* Flag indicating that a command has proceeded the inferior past the
145 current breakpoint. */
147 int breakpoint_proceeded
;
149 /* Nonzero if stopped due to a step command. */
153 /* Nonzero if stopped due to completion of a stack dummy routine. */
155 int stop_stack_dummy
;
157 /* Nonzero if stopped due to a random (unexpected) signal in inferior
160 int stopped_by_random_signal
;
162 /* Range to single step within.
163 If this is nonzero, respond to a single-step signal
164 by continuing to step if the pc is in this range. */
166 CORE_ADDR step_range_start
; /* Inclusive */
167 CORE_ADDR step_range_end
; /* Exclusive */
169 /* Stack frame address as of when stepping command was issued.
170 This is how we know when we step into a subroutine call,
171 and how to set the frame for the breakpoint used to step out. */
173 FRAME_ADDR step_frame_address
;
175 /* 1 means step over all subroutine calls.
176 0 means don't step over calls (used by stepi).
177 -1 means step over calls to undebuggable functions. */
181 /* If stepping, nonzero means step count is > 1
182 so don't print frame next time inferior stops
183 if it stops due to stepping. */
187 /* Environment to use for running inferior,
188 in format described in environ.h. */
190 struct environ
*inferior_environ
;
195 tty_command (file
, from_tty
)
200 error_no_arg ("terminal name for running target process");
202 inferior_io_terminal
= savestring (file
, strlen (file
));
206 run_command (args
, from_tty
)
217 !query ("The program being debugged has been started already.\n\
218 Start it from the beginning? "))
219 error ("Program not restarted.");
223 exec_file
= (char *) get_exec_file (0);
225 /* The exec file is re-read every time we do a generic_mourn_inferior, so
226 we just have to worry about the symbol file. */
232 cmd
= concat ("set args ", args
, NULL
);
233 make_cleanup (free
, cmd
);
234 execute_command (cmd
, from_tty
);
239 puts_filtered("Starting program: ");
241 puts_filtered(exec_file
);
243 puts_filtered(inferior_args
);
248 target_create_inferior (exec_file
, inferior_args
,
249 environ_vector (inferior_environ
));
253 continue_command (proc_count_exp
, from_tty
)
254 char *proc_count_exp
;
259 /* If have argument, set proceed count of breakpoint we stopped at. */
261 if (proc_count_exp
!= NULL
)
263 bpstat bs
= stop_bpstat
;
264 int num
= bpstat_num (&bs
);
265 if (num
== 0 && from_tty
)
268 ("Not stopped at any breakpoint; argument ignored.\n");
272 set_ignore_count (num
,
273 parse_and_eval_address (proc_count_exp
) - 1,
275 /* set_ignore_count prints a message ending with a period.
276 So print two spaces before "Continuing.". */
278 printf_filtered (" ");
279 num
= bpstat_num (&bs
);
284 printf_filtered ("Continuing.\n");
286 clear_proceed_status ();
288 proceed ((CORE_ADDR
) -1, -1, 0);
291 /* Step until outside of current statement. */
295 step_command (count_string
, from_tty
)
299 step_1 (0, 0, count_string
);
302 /* Likewise, but skip over subroutine calls as if single instructions. */
306 next_command (count_string
, from_tty
)
310 step_1 (1, 0, count_string
);
313 /* Likewise, but step only one instruction. */
317 stepi_command (count_string
, from_tty
)
321 step_1 (0, 1, count_string
);
326 nexti_command (count_string
, from_tty
)
330 step_1 (1, 1, count_string
);
334 step_1 (skip_subroutines
, single_inst
, count_string
)
335 int skip_subroutines
;
339 register int count
= 1;
341 struct cleanup
*cleanups
= 0;
344 count
= count_string
? parse_and_eval_address (count_string
) : 1;
346 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
348 enable_longjmp_breakpoint();
349 cleanups
= make_cleanup(disable_longjmp_breakpoint
, 0);
352 for (; count
> 0; count
--)
354 clear_proceed_status ();
356 fr
= get_current_frame ();
357 if (!fr
) /* Avoid coredump here. Why tho? */
358 error ("No current frame");
359 step_frame_address
= FRAME_FP (fr
);
363 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
364 if (step_range_end
== 0)
366 struct minimal_symbol
*msymbol
;
368 msymbol
= lookup_minimal_symbol_by_pc (stop_pc
);
369 target_terminal_ours ();
370 printf_filtered ("Current function has no line number information.\n");
373 /* No info or after _etext ("Can't happen") */
374 if (msymbol
== NULL
|| SYMBOL_NAME (msymbol
+ 1) == NULL
)
375 error ("No data available on pc function.");
377 printf_filtered ("Single stepping until function exit.\n");
380 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
381 step_range_end
= SYMBOL_VALUE_ADDRESS (msymbol
+ 1);
386 /* Say we are stepping, but stop after one insn whatever it does.
387 Don't step through subroutine calls even to undebuggable
389 step_range_start
= step_range_end
= 1;
390 if (!skip_subroutines
)
394 if (skip_subroutines
)
397 step_multi
= (count
> 1);
398 proceed ((CORE_ADDR
) -1, -1, 1);
401 #if defined (SHIFT_INST_REGS)
402 write_register (NNPC_REGNUM
, read_register (NPC_REGNUM
));
403 write_register (NPC_REGNUM
, read_register (PC_REGNUM
));
407 if (!single_inst
|| skip_subroutines
)
408 do_cleanups(cleanups
);
411 /* Continue program at specified address. */
414 jump_command (arg
, from_tty
)
418 register CORE_ADDR addr
;
419 struct symtabs_and_lines sals
;
420 struct symtab_and_line sal
;
427 error_no_arg ("starting address");
429 sals
= decode_line_spec_1 (arg
, 1);
432 error ("Unreasonable jump request");
436 free ((PTR
)sals
.sals
);
438 if (sal
.symtab
== 0 && sal
.pc
== 0)
439 error ("No source file has been specified.");
441 resolve_sal_pc (&sal
); /* May error out */
443 /* See if we are trying to jump to another function. */
444 fn
= get_frame_function (get_current_frame ());
445 sfn
= find_pc_function (sal
.pc
);
446 if (fn
!= NULL
&& sfn
!= fn
)
448 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
449 SYMBOL_SOURCE_NAME (fn
)))
451 error ("Not confirmed.");
456 addr
= ADDR_BITS_SET (sal
.pc
);
459 printf_filtered ("Continuing at %s.\n", local_hex_string(addr
));
461 clear_proceed_status ();
462 proceed (addr
, 0, 0);
465 /* Continue program giving it specified signal. */
468 signal_command (signum_exp
, from_tty
)
474 dont_repeat (); /* Too dangerous. */
478 error_no_arg ("signal number");
480 signum
= parse_and_eval_address (signum_exp
);
483 printf_filtered ("Continuing with signal %d.\n", signum
);
485 clear_proceed_status ();
486 proceed (stop_pc
, signum
, 0);
489 /* Execute a "stack dummy", a piece of code stored in the stack
490 by the debugger to be executed in the inferior.
492 To call: first, do PUSH_DUMMY_FRAME.
493 Then push the contents of the dummy. It should end with a breakpoint insn.
494 Then call here, passing address at which to start the dummy.
496 The contents of all registers are saved before the dummy frame is popped
497 and copied into the buffer BUFFER.
499 The dummy's frame is automatically popped whenever that break is hit.
500 If that is the first time the program stops, run_stack_dummy
501 returns to its caller with that frame already gone.
502 Otherwise, the caller never gets returned to. */
504 /* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
506 static int stack_dummy_testing
= 0;
509 run_stack_dummy (addr
, buffer
)
511 char buffer
[REGISTER_BYTES
];
513 /* Now proceed, having reached the desired place. */
514 clear_proceed_status ();
515 if (stack_dummy_testing
& 4)
520 proceed_to_finish
= 1; /* We want stop_registers, please... */
521 proceed (addr
, 0, 0);
523 if (!stop_stack_dummy
)
525 "Cannot continue previously requested operation". */
527 The program being debugged stopped while in a function called from GDB.\n\
528 The expression which contained the function call has been discarded.");
530 /* On return, the stack dummy has been popped already. */
532 memcpy (buffer
, stop_registers
, sizeof stop_registers
);
535 /* Proceed until we reach a different source line with pc greater than
536 our current one or exit the function. We skip calls in both cases.
538 Note that eventually this command should probably be changed so
539 that only source lines are printed out when we hit the breakpoint
540 we set. I'm going to postpone this until after a hopeful rewrite
541 of wait_for_inferior and the proceed status code. -- randy */
545 until_next_command (from_tty
)
551 struct symtab_and_line sal
;
553 clear_proceed_status ();
555 frame
= get_current_frame ();
557 /* Step until either exited from this function or greater
558 than the current line (if in symbolic section) or pc (if
562 func
= find_pc_function (pc
);
566 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
569 error ("Execution is not within a known function.");
571 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
576 sal
= find_pc_line (pc
, 0);
578 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
579 step_range_end
= sal
.end
;
583 step_frame_address
= FRAME_FP (frame
);
585 step_multi
= 0; /* Only one call to proceed */
587 proceed ((CORE_ADDR
) -1, -1, 1);
591 until_command (arg
, from_tty
)
595 if (!target_has_execution
)
596 error ("The program is not running.");
598 until_break_command (arg
, from_tty
);
600 until_next_command (from_tty
);
603 /* "finish": Set a temporary breakpoint at the place
604 the selected frame will return to, then continue. */
607 finish_command (arg
, from_tty
)
611 struct symtab_and_line sal
;
612 register FRAME frame
;
613 struct frame_info
*fi
;
614 register struct symbol
*function
;
615 struct breakpoint
*breakpoint
;
616 struct cleanup
*old_chain
;
619 error ("The \"finish\" command does not take any arguments.");
620 if (!target_has_execution
)
621 error ("The program is not running.");
622 if (selected_frame
== NULL
)
623 error ("No selected frame.");
625 frame
= get_prev_frame (selected_frame
);
627 error ("\"finish\" not meaningful in the outermost frame.");
629 clear_proceed_status ();
631 fi
= get_frame_info (frame
);
632 sal
= find_pc_line (fi
->pc
, 0);
635 breakpoint
= set_momentary_breakpoint (sal
, frame
, bp_finish
);
637 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
639 /* Find the function we will return from. */
641 fi
= get_frame_info (selected_frame
);
642 function
= find_pc_function (fi
->pc
);
644 /* Print info on the selected frame, including level number
648 printf_filtered ("Run till exit from ");
649 print_stack_frame (selected_frame
, selected_frame_level
, 0);
652 proceed_to_finish
= 1; /* We want stop_registers, please... */
653 proceed ((CORE_ADDR
) -1, -1, 0);
655 /* Did we stop at our breakpoint? */
656 if (bpstat_find_breakpoint(stop_bpstat
, breakpoint
) != NULL
659 struct type
*value_type
;
663 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
665 fatal ("internal: finish_command: function has no target type");
667 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
670 funcaddr
= BLOCK_START (SYMBOL_BLOCK_VALUE (function
));
672 val
= value_being_returned (value_type
, stop_registers
,
673 using_struct_return (value_of_variable (function
),
676 BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function
))));
678 printf_filtered ("Value returned is $%d = ", record_latest_value (val
));
679 value_print (val
, stdout
, 0, Val_no_prettyprint
);
680 printf_filtered ("\n");
682 do_cleanups(old_chain
);
687 program_info (args
, from_tty
)
691 bpstat bs
= stop_bpstat
;
692 int num
= bpstat_num (&bs
);
694 if (!target_has_execution
)
696 printf_filtered ("The program being debugged is not being run.\n");
700 target_files_info ();
701 printf_filtered ("Program stopped at %s.\n", local_hex_string(stop_pc
));
703 printf_filtered ("It stopped after being stepped.\n");
706 /* There may be several breakpoints in the same place, so this
707 isn't as strange as it seems. */
711 printf_filtered ("It stopped at a breakpoint that has since been deleted.\n");
713 printf_filtered ("It stopped at breakpoint %d.\n", num
);
714 num
= bpstat_num (&bs
);
717 else if (stop_signal
) {
718 #ifdef PRINT_RANDOM_SIGNAL
719 PRINT_RANDOM_SIGNAL (stop_signal
);
721 printf_filtered ("It stopped with signal %d (%s).\n",
722 stop_signal
, safe_strsignal (stop_signal
));
727 printf_filtered ("Type \"info stack\" or \"info registers\" for more information.\n");
731 environment_info (var
, from_tty
)
737 register char *val
= get_in_environ (inferior_environ
, var
);
741 puts_filtered (" = ");
743 puts_filtered ("\n");
747 puts_filtered ("Environment variable \"");
749 puts_filtered ("\" not defined.\n");
754 register char **vector
= environ_vector (inferior_environ
);
757 puts_filtered (*vector
++);
758 puts_filtered ("\n");
764 set_environment_command (arg
, from_tty
)
768 register char *p
, *val
, *var
;
772 error_no_arg ("environment variable and value");
774 /* Find seperation between variable name and value */
775 p
= (char *) strchr (arg
, '=');
776 val
= (char *) strchr (arg
, ' ');
778 if (p
!= 0 && val
!= 0)
780 /* We have both a space and an equals. If the space is before the
781 equals, walk forward over the spaces til we see a nonspace
782 (possibly the equals). */
787 /* Now if the = is after the char following the spaces,
788 take the char following the spaces. */
792 else if (val
!= 0 && p
== 0)
796 error_no_arg ("environment variable to set");
798 if (p
== 0 || p
[1] == 0)
802 p
= arg
+ strlen (arg
); /* So that savestring below will work */
806 /* Not setting variable value to null */
808 while (*val
== ' ' || *val
== '\t')
812 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t')) p
--;
814 var
= savestring (arg
, p
- arg
);
817 printf_filtered ("Setting environment variable \"%s\" to null value.\n", var
);
818 set_in_environ (inferior_environ
, var
, "");
821 set_in_environ (inferior_environ
, var
, val
);
826 unset_environment_command (var
, from_tty
)
832 /* If there is no argument, delete all environment variables.
833 Ask for confirmation if reading from the terminal. */
834 if (!from_tty
|| query ("Delete all environment variables? "))
836 free_environ (inferior_environ
);
837 inferior_environ
= make_environ ();
841 unset_in_environ (inferior_environ
, var
);
844 /* Handle the execution path (PATH variable) */
846 static const char path_var_name
[] = "PATH";
850 path_info (args
, from_tty
)
854 puts_filtered ("Executable and object file path: ");
855 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
856 puts_filtered ("\n");
859 /* Add zero or more directories to the front of the execution path. */
862 path_command (dirname
, from_tty
)
869 exec_path
= strsave (get_in_environ (inferior_environ
, path_var_name
));
870 mod_path (dirname
, &exec_path
);
871 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
874 path_info ((char *)NULL
, from_tty
);
880 return ADDR_BITS_REMOVE ((CORE_ADDR
) read_register (PC_REGNUM
));
887 write_register (PC_REGNUM
, (long) val
);
889 write_register (NPC_REGNUM
, (long) val
+4);
894 const char * const reg_names
[] = REGISTER_NAMES
;
896 /* Print out the machine register regnum. If regnum is -1,
897 print all registers (fpregs == 1) or all non-float registers
900 For most machines, having all_registers_info() print the
901 register(s) one per line is good enough. If a different format
902 is required, (eg, for MIPS or Pyramid 90x, which both have
903 lots of regs), or there is an existing convention for showing
904 all the registers, define the macro DO_REGISTERS_INFO(regnum, fp)
905 to provide that format. */
907 #if !defined (DO_REGISTERS_INFO)
908 #define DO_REGISTERS_INFO(regnum, fp) do_registers_info(regnum, fp)
910 do_registers_info (regnum
, fpregs
)
916 for (i
= 0; i
< NUM_REGS
; i
++)
918 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
919 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
921 /* Decide between printing all regs, nonfloat regs, or specific reg. */
923 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
&& !fpregs
)
930 fputs_filtered (reg_names
[i
], stdout
);
931 print_spaces_filtered (15 - strlen (reg_names
[i
]), stdout
);
933 /* Get the data in raw format, then convert also to virtual format. */
934 if (read_relative_register_raw_bytes (i
, raw_buffer
))
936 printf_filtered ("Invalid register contents\n");
940 REGISTER_CONVERT_TO_VIRTUAL (i
, raw_buffer
, virtual_buffer
);
942 /* If virtual format is floating, print it that way, and in raw hex. */
943 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
944 && ! INVALID_FLOAT (virtual_buffer
, REGISTER_VIRTUAL_SIZE (i
)))
948 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0,
949 stdout
, 0, 1, 0, Val_pretty_default
);
951 printf_filtered ("\t(raw 0x");
952 for (j
= 0; j
< REGISTER_RAW_SIZE (i
); j
++)
953 printf_filtered ("%02x", (unsigned char)raw_buffer
[j
]);
954 printf_filtered (")");
957 /* FIXME! val_print probably can handle all of these cases now... */
959 /* Else if virtual format is too long for printf,
960 print in hex a byte at a time. */
961 else if (REGISTER_VIRTUAL_SIZE (i
) > sizeof (long))
964 printf_filtered ("0x");
965 for (j
= 0; j
< REGISTER_VIRTUAL_SIZE (i
); j
++)
966 printf_filtered ("%02x", (unsigned char)virtual_buffer
[j
]);
968 /* Else print as integer in hex and in decimal. */
971 val_print (REGISTER_VIRTUAL_TYPE (i
), raw_buffer
, 0,
972 stdout
, 'x', 1, 0, Val_pretty_default
);
973 printf_filtered ("\t");
974 val_print (REGISTER_VIRTUAL_TYPE (i
), raw_buffer
, 0,
975 stdout
, 0, 1, 0, Val_pretty_default
);
978 /* The SPARC wants to print even-numbered float regs as doubles
979 in addition to printing them as floats. */
980 #ifdef PRINT_REGISTER_HOOK
981 PRINT_REGISTER_HOOK (i
);
984 printf_filtered ("\n");
987 #endif /* no DO_REGISTERS_INFO. */
990 registers_info (addr_exp
, fpregs
)
997 if (!target_has_registers
)
998 error ("The program has no registers now.");
1002 DO_REGISTERS_INFO(-1, fpregs
);
1008 if (addr_exp
[0] == '$')
1011 while (*end
!= '\0' && *end
!= ' ' && *end
!= '\t')
1013 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1014 if (!strncmp (addr_exp
, reg_names
[regnum
], end
- addr_exp
)
1015 && strlen (reg_names
[regnum
]) == end
- addr_exp
)
1017 if (*addr_exp
>= '0' && *addr_exp
<= '9')
1018 regnum
= atoi (addr_exp
); /* Take a number */
1019 if (regnum
>= NUM_REGS
) /* Bad name, or bad number */
1020 error ("%.*s: invalid register", end
- addr_exp
, addr_exp
);
1023 DO_REGISTERS_INFO(regnum
, fpregs
);
1026 while (*addr_exp
== ' ' || *addr_exp
== '\t')
1028 } while (*addr_exp
!= '\0');
1032 all_registers_info (addr_exp
, from_tty
)
1036 registers_info (addr_exp
, 1);
1040 nofp_registers_info (addr_exp
, from_tty
)
1044 registers_info (addr_exp
, 0);
1049 * Should save/restore the tty state since it might be that the
1050 * program to be debugged was started on this tty and it wants
1051 * the tty in some state other than what we want. If it's running
1052 * on another terminal or without a terminal, then saving and
1053 * restoring the tty state is a harmless no-op.
1054 * This only needs to be done if we are attaching to a process.
1059 takes a program started up outside of gdb and ``attaches'' to it.
1060 This stops it cold in its tracks and allows us to start debugging it.
1061 and wait for the trace-trap that results from attaching. */
1064 attach_command (args
, from_tty
)
1068 dont_repeat (); /* Not for the faint of heart */
1070 if (target_has_execution
)
1072 if (query ("A program is being debugged already. Kill it? "))
1075 error ("Inferior not killed.");
1078 target_attach (args
, from_tty
);
1080 /* Set up the "saved terminal modes" of the inferior
1081 based on what modes we are starting it with. */
1082 target_terminal_init ();
1084 /* Install inferior's terminal modes. */
1085 target_terminal_inferior ();
1087 /* Set up execution context to know that we should return from
1088 wait_for_inferior as soon as the target reports a stop. */
1089 init_wait_for_inferior ();
1090 clear_proceed_status ();
1091 stop_soon_quietly
= 1;
1093 wait_for_inferior ();
1096 /* Add shared library symbols from the newly attached process, if any. */
1097 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
1105 * takes a program previously attached to and detaches it.
1106 * The program resumes execution and will no longer stop
1107 * on signals, etc. We better not have left any breakpoints
1108 * in the program or it'll die when it hits one. For this
1109 * to work, it may be necessary for the process to have been
1110 * previously attached. It *might* work if the program was
1111 * started via the normal ptrace (PTRACE_TRACEME).
1115 detach_command (args
, from_tty
)
1119 dont_repeat (); /* Not for the faint of heart */
1120 target_detach (args
, from_tty
);
1125 float_info (addr_exp
, from_tty
)
1132 printf_filtered ("No floating point info available for this processor.\n");
1138 unset_command (args
, from_tty
)
1142 printf_filtered ("\"unset\" must be followed by the name of an unset subcommand.\n");
1143 help_list (unsetlist
, "unset ", -1, stdout
);
1147 _initialize_infcmd ()
1149 struct cmd_list_element
*c
;
1151 add_com ("tty", class_run
, tty_command
,
1152 "Set terminal for future runs of program being debugged.");
1155 (add_set_cmd ("args", class_run
, var_string_noescape
, (char *)&inferior_args
,
1157 "Set arguments to give program being debugged when it is started.\n\
1158 Follow this command with any number of args, to be passed to the program.",
1163 ("environment", no_class
, environment_info
,
1164 "The environment to give the program, or one variable's value.\n\
1165 With an argument VAR, prints the value of environment variable VAR to\n\
1166 give the program being debugged. With no arguments, prints the entire\n\
1167 environment to be given to the program.", &showlist
);
1168 c
->completer
= noop_completer
;
1170 add_prefix_cmd ("unset", no_class
, unset_command
,
1171 "Complement to certain \"set\" commands",
1172 &unsetlist
, "unset ", 0, &cmdlist
);
1174 c
= add_cmd ("environment", class_run
, unset_environment_command
,
1175 "Cancel environment variable VAR for the program.\n\
1176 This does not affect the program until the next \"run\" command.",
1178 c
->completer
= noop_completer
;
1180 c
= add_cmd ("environment", class_run
, set_environment_command
,
1181 "Set environment variable value to give the program.\n\
1182 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
1183 VALUES of environment variables are uninterpreted strings.\n\
1184 This does not affect the program until the next \"run\" command.",
1186 c
->completer
= noop_completer
;
1188 add_com ("path", class_files
, path_command
,
1189 "Add directory DIR(s) to beginning of search path for object files.\n\
1190 $cwd in the path means the current working directory.\n\
1191 This path is equivalent to the $PATH shell variable. It is a list of\n\
1192 directories, separated by colons. These directories are searched to find\n\
1193 fully linked executable files and separately compiled object files as needed.");
1195 c
= add_cmd ("paths", no_class
, path_info
,
1196 "Current search path for finding object files.\n\
1197 $cwd in the path means the current working directory.\n\
1198 This path is equivalent to the $PATH shell variable. It is a list of\n\
1199 directories, separated by colons. These directories are searched to find\n\
1200 fully linked executable files and separately compiled object files as needed.", &showlist
);
1201 c
->completer
= noop_completer
;
1203 add_com ("attach", class_run
, attach_command
,
1204 "Attach to a process or file outside of GDB.\n\
1205 This command attaches to another target, of the same type as your last\n\
1206 `target' command (`info files' will show your target stack).\n\
1207 The command may take as argument a process id or a device file.\n\
1208 For a process id, you must have permission to send the process a signal,\n\
1209 and it must have the same effective uid as the debugger.\n\
1210 When using \"attach\", you should use the \"file\" command to specify\n\
1211 the program running in the process, and to load its symbol table.");
1213 add_com ("detach", class_run
, detach_command
,
1214 "Detach a process or file previously attached.\n\
1215 If a process, it is no longer traced, and it continues its execution. If you\n\
1216 were debugging a file, the file is closed and gdb no longer accesses it.");
1218 add_com ("signal", class_run
, signal_command
,
1219 "Continue program giving it signal number SIGNUMBER.");
1221 add_com ("stepi", class_run
, stepi_command
,
1222 "Step one instruction exactly.\n\
1223 Argument N means do this N times (or till program stops for another reason).");
1224 add_com_alias ("si", "stepi", class_alias
, 0);
1226 add_com ("nexti", class_run
, nexti_command
,
1227 "Step one instruction, but proceed through subroutine calls.\n\
1228 Argument N means do this N times (or till program stops for another reason).");
1229 add_com_alias ("ni", "nexti", class_alias
, 0);
1231 add_com ("finish", class_run
, finish_command
,
1232 "Execute until selected stack frame returns.\n\
1233 Upon return, the value returned is printed and put in the value history.");
1235 add_com ("next", class_run
, next_command
,
1236 "Step program, proceeding through subroutine calls.\n\
1237 Like the \"step\" command as long as subroutine calls do not happen;\n\
1238 when they do, the call is treated as one instruction.\n\
1239 Argument N means do this N times (or till program stops for another reason).");
1240 add_com_alias ("n", "next", class_run
, 1);
1242 add_com ("step", class_run
, step_command
,
1243 "Step program until it reaches a different source line.\n\
1244 Argument N means do this N times (or till program stops for another reason).");
1245 add_com_alias ("s", "step", class_run
, 1);
1247 add_com ("until", class_run
, until_command
,
1248 "Execute until the program reaches a source line greater than the current\n\
1249 or a specified line or address or function (same args as break command).\n\
1250 Execution will also stop upon exit from the current stack frame.");
1251 add_com_alias ("u", "until", class_run
, 1);
1253 add_com ("jump", class_run
, jump_command
,
1254 "Continue program being debugged at specified line or address.\n\
1255 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
1256 for an address to start at.");
1258 add_com ("continue", class_run
, continue_command
,
1259 "Continue program being debugged, after signal or breakpoint.\n\
1260 If proceeding from breakpoint, a number N may be used as an argument:\n\
1261 then the same breakpoint won't break until the Nth time it is reached.");
1262 add_com_alias ("c", "cont", class_run
, 1);
1263 add_com_alias ("fg", "cont", class_run
, 1);
1265 add_com ("run", class_run
, run_command
,
1266 "Start debugged program. You may specify arguments to give it.\n\
1267 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
1268 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
1269 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
1270 To cancel previous arguments and run with no arguments,\n\
1271 use \"set args\" without arguments.");
1272 add_com_alias ("r", "run", class_run
, 1);
1274 add_info ("registers", nofp_registers_info
,
1275 "List of integer registers and their contents, for selected stack frame.\n\
1276 Register name as argument means describe only that register.");
1278 add_info ("all-registers", all_registers_info
,
1279 "List of all registers and their contents, for selected stack frame.\n\
1280 Register name as argument means describe only that register.");
1282 add_info ("program", program_info
,
1283 "Execution status of the program.");
1285 add_info ("float", float_info
,
1286 "Print the status of the floating point unit\n");
1288 inferior_args
= savestring ("", 1); /* Initially no args */
1289 inferior_environ
= make_environ ();
1290 init_environ (inferior_environ
);