![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to infcmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to infcmd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* Memory-access and commands for inferior process, for GDB.
2: Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
3:
4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5: WARRANTY. No author or distributor accepts responsibility to anyone
6: for the consequences of using it or for whether it serves any
7: particular purpose or works at all, unless he says so in writing.
8: Refer to the GDB General Public License for full details.
9:
10: Everyone is granted permission to copy, modify and redistribute GDB,
11: but only under the conditions described in the GDB General Public
12: License. A copy of this license is supposed to have been given to you
13: along with GDB so you can know your rights and responsibilities. It
14: should be in a file named COPYING. Among other things, the copyright
15: notice and this notice must be preserved on all copies.
16:
17: In other words, go ahead and share GDB, but don't try to stop
18: anyone else from sharing it farther. Help stamp out software hoarding!
19: */
20:
21: #include "defs.h"
22: #include "initialize.h"
23: #include "symtab.h"
24: #include "param.h"
25: #include "frame.h"
26: #include "inferior.h"
27: #include "environ.h"
28: #include "value.h"
29:
30: #include <stdio.h>
31: #include <signal.h>
32: #include <sys/param.h>
33:
34: extern char *sys_siglist[];
35:
36: #define ERROR_NO_INFERIOR \
37: if (inferior_pid == 0) error ("The program is not being run.");
38:
39: /* String containing arguments to give to the program,
40: with a space added at the front. Just a space means no args. */
41:
42: static char *inferior_args;
43:
44: /* File name for default use for standard in/out in the inferior. */
45:
46: char *inferior_io_terminal;
47:
48: /* Pid of our debugged inferior, or 0 if no inferior now. */
49:
50: int inferior_pid;
51:
52: /* Last signal that the inferior received (why it stopped). */
53:
54: int stop_signal;
55:
56: /* Address at which inferior stopped. */
57:
58: CORE_ADDR stop_pc;
59:
60: /* Stack frame when program stopped. */
61:
62: FRAME stop_frame;
63:
64: /* Number of breakpoint it stopped at, or 0 if none. */
65:
66: int stop_breakpoint;
67:
68: /* Nonzero if stopped due to a step command. */
69:
70: int stop_step;
71:
72: /* Nonzero if stopped due to completion of a stack dummy routine. */
73:
74: int stop_stack_dummy;
75:
76: /* Range to single step within.
77: If this is nonzero, respond to a single-step signal
78: by continuing to step if the pc is in this range. */
79:
80: CORE_ADDR step_range_start; /* Inclusive */
81: CORE_ADDR step_range_end; /* Exclusive */
82:
83: /* Stack frame address as of when stepping command was issued.
84: This is how we know when we step into a subroutine call,
85: and how to set the frame for the breakpoint used to step out. */
86:
87: CORE_ADDR step_frame;
88:
89: /* 1 means step over all subroutine calls.
90: -1 means step over calls to undebuggable functions. */
91:
92: int step_over_calls;
93:
94: /* If stepping, nonzero means step count is > 1
95: so don't print frame next time inferior stops
96: if it stops due to stepping. */
97:
98: int step_multi;
99:
100: /* Environment to use for running inferior,
101: in format described in environ.h. */
102:
103: struct environ *inferior_environ;
104:
105: CORE_ADDR read_pc ();
106: struct command_line *get_breakpoint_commands ();
107:
108: START_FILE
109:
110: int
111: have_inferior_p ()
112: {
113: return inferior_pid != 0;
114: }
115:
116: static void
117: set_args_command (args)
118: char *args;
119: {
120: free (inferior_args);
121: if (!args) args = "";
122: inferior_args = concat (" ", args, "");
123: }
124:
125: void
126: tty_command (file)
127: char *file;
128: {
129: if (file == 0)
130: error_no_arg ("terminal name for running target process");
131:
132: inferior_io_terminal = savestring (file, strlen (file));
133: }
134:
135: static void
136: run_command (args, from_tty)
137: char *args;
138: int from_tty;
139: {
140: extern char **environ;
141: register int i;
142: char *exec_file;
143: char *allargs;
144:
145: extern int sys_nerr;
146: extern char *sys_errlist[];
147: extern int errno;
148:
149: dont_repeat ();
150:
151: if (inferior_pid)
152: {
153: if (query ("The program being debugged has been started already.\n\
154: Start it from the beginning? "))
155: kill_inferior ();
156: else
157: error ("Program already started.");
158: }
159:
160: if (remote_debugging)
161: {
162: free (allargs);
163: if (from_tty)
164: {
165: printf ("Starting program: %s%s\n",
166: exec_file, inferior_args);
167: fflush (stdout);
168: }
169: }
170: else
171: {
172: if (args)
173: set_args_command (args);
174:
175: exec_file = (char *) get_exec_file (1);
176: if (from_tty)
177: {
178: printf ("Starting program: %s%s\n",
179: exec_file, inferior_args);
180: fflush (stdout);
181: }
182:
183: allargs = concat ("exec ", exec_file, inferior_args);
184: inferior_pid = create_inferior (allargs, environ_vector (inferior_environ));
185: }
186:
187: clear_proceed_status ();
188:
189: start_inferior ();
190: }
191:
192: void
193: cont_command (proc_count_exp, from_tty)
194: char *proc_count_exp;
195: int from_tty;
196: {
197: ERROR_NO_INFERIOR;
198:
199: clear_proceed_status ();
200:
201: /* If have argument, set proceed count of breakpoint we stopped at. */
202:
203: if (stop_breakpoint && proc_count_exp)
204: {
205: set_ignore_count (stop_breakpoint,
206: parse_and_eval_address (proc_count_exp) - 1,
207: from_tty);
208: if (from_tty)
209: printf (" ");
210: }
211:
212: if (from_tty)
213: printf ("Continuing.\n");
214:
215: proceed (-1, -1, 0);
216: }
217:
218: /* Step until outside of current statement. */
219: static void step_1 ();
220:
221: static void
222: step_command (count_string)
223: {
224: step_1 (0, 0, count_string);
225: }
226:
227: /* Likewise, but skip over subroutine calls as if single instructions. */
228:
229: static void
230: next_command (count_string)
231: {
232: step_1 (1, 0, count_string);
233: }
234:
235: /* Likewise, but step only one instruction. */
236:
237: static void
238: stepi_command (count_string)
239: {
240: step_1 (0, 1, count_string);
241: }
242:
243: static void
244: nexti_command (count_string)
245: {
246: step_1 (1, 1, count_string);
247: }
248:
249: static void
250: step_1 (skip_subroutines, single_inst, count_string)
251: int skip_subroutines;
252: int single_inst;
253: char *count_string;
254: {
255: register int count = 1;
256:
257: ERROR_NO_INFERIOR;
258: count = count_string ? parse_and_eval_address (count_string) : 1;
259:
260: for (; count > 0; count--)
261: {
262: clear_proceed_status ();
263:
264: step_frame = get_current_frame ();
265:
266: if (! single_inst)
267: {
268: find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
269: if (step_range_end == 0)
270: {
271: terminal_ours ();
272: error ("Current function has no line number information.");
273: }
274: }
275: else
276: {
277: /* Say we are stepping, but stop after one insn whatever it does.
278: Don't step through subroutine calls even to undebuggable functions. */
279: step_range_start = step_range_end = 1;
280: if (!skip_subroutines)
281: step_over_calls = 0;
282: }
283:
284: if (skip_subroutines)
285: step_over_calls = 1;
286:
287: step_multi = (count > 1);
288: proceed (-1, -1, 1);
289: if (! stop_step)
290: break;
291: }
292: }
293:
294: /* Continue program at specified address. */
295:
296: static void
297: jump_command (arg, from_tty)
298: char *arg;
299: int from_tty;
300: {
301: register CORE_ADDR addr;
302: struct symtab_and_line sal;
303:
304: ERROR_NO_INFERIOR;
305:
306: if (!arg)
307: error_no_arg ("starting address");
308:
309: sal = decode_line_spec (arg, 1);
310:
311: if (sal.symtab == 0 && sal.pc == 0)
312: error ("No source file has been specified.");
313:
314: if (sal.pc == 0)
315: sal.pc = find_line_pc (sal.symtab, sal.line);
316:
317: {
318: struct symbol *fn = get_frame_function (get_current_frame ());
319: struct symbol *sfn = find_pc_function (sal.pc);
320: if (fn != 0 && sfn != fn
321: && ! query ("Line %d is not in `%s'. Jump anyway? ",
322: sal.line, SYMBOL_NAME (fn)))
323: error ("Not confirmed.");
324: }
325:
326: if (sal.pc == 0)
327: error ("No line %d in file \"%s\".", sal.line, sal.symtab->filename);
328:
329: addr = sal.pc;
330:
331: clear_proceed_status ();
332:
333: if (from_tty)
334: printf ("Continuing at 0x%x.\n", addr);
335:
336: proceed (addr, 0, 0);
337: }
338:
339: /* Continue program giving it specified signal. */
340:
341: static void
342: signal_command (signum_exp, from_tty)
343: char *signum_exp;
344: int from_tty;
345: {
346: register int signum;
347:
348: dont_repeat (); /* Too dangerous. */
349: ERROR_NO_INFERIOR;
350:
351: if (!signum_exp)
352: error_no_arg ("signal number");
353:
354: signum = parse_and_eval_address (signum_exp);
355:
356: clear_proceed_status ();
357:
358: if (from_tty)
359: printf ("Continuing with signal %d.\n", signum);
360:
361: proceed (stop_pc, signum, 0);
362: }
363:
364: /* Execute a "stack dummy", a piece of code stored in the stack
365: by the debugger to be executed in the inferior.
366:
367: To call: first, do PUSH_DUMMY_FRAME.
368: Then push the contents of the dummy. It should end with a breakpoint insn.
369: Then call here, passing address at which to start the dummy.
370:
371: The contents of all registers are saved before the dummy frame is popped
372: and copied into the buffer BUFFER.
373:
374: The dummy's frame is automatically popped whenever that break is hit.
375: If that is the first time the program stops, run_stack_dummy
376: returns to its caller with that frame already gone.
377: Otherwise, the caller never gets returned to. */
378:
379: /* 4 => return instead of letting the stack dummy run. */
380:
381: static int stack_dummy_testing = 0;
382:
383: void
384: run_stack_dummy (addr, buffer)
385: CORE_ADDR addr;
386: REGISTER_TYPE *buffer;
387: {
388: int saved_pc_changed = pc_changed;
389: int saved_stop_signal = stop_signal;
390: int saved_stop_pc = stop_pc;
391: int saved_stop_frame = stop_frame;
392: int saved_stop_breakpoint = stop_breakpoint;
393: int saved_stop_step = stop_step;
394: int saved_stop_stack_dummy = stop_stack_dummy;
395: FRAME saved_selected_frame;
396: int saved_selected_level;
397: struct command_line *saved_breakpoint_commands
398: = get_breakpoint_commands ();
399:
400: record_selected_frame (&saved_selected_frame, &saved_selected_level);
401:
402: /* Now proceed, having reached the desired place. */
403: clear_proceed_status ();
404: if (stack_dummy_testing & 4)
405: {
406: POP_FRAME;
407: return;
408: }
409: proceed (addr, 0, 0);
410:
411: if (!stop_stack_dummy)
412: error ("Cannot continue previously requested operation.");
413:
414: set_breakpoint_commands (saved_breakpoint_commands);
415: select_frame (saved_selected_frame, saved_selected_level);
416: stop_signal = saved_stop_signal;
417: stop_pc = saved_stop_pc;
418: stop_frame = saved_stop_frame;
419: stop_breakpoint = saved_stop_breakpoint;
420: stop_step = saved_stop_step;
421: stop_stack_dummy = saved_stop_stack_dummy;
422: pc_changed = saved_pc_changed;
423:
424: /* On return, the stack dummy has been popped already. */
425:
426: bcopy (stop_registers, buffer, sizeof stop_registers);
427: }
428:
429: /* "finish": Set a temporary breakpoint at the place
430: the selected frame will return to, then continue. */
431:
432: static void
433: finish_command (arg, from_tty)
434: char *arg;
435: int from_tty;
436: {
437: struct symtab_and_line sal;
438: register FRAME frame;
439: struct frame_info fi;
440:
441: register struct symbol *function;
442:
443: if (!have_inferior_p ())
444: error ("The program is not being run.");
445: if (arg)
446: error ("The \"finish\" command does not take any arguments.");
447:
448: frame = get_prev_frame (selected_frame);
449: if (frame == 0)
450: error ("\"finish\" not meaningful in the outermost frame.");
451:
452: clear_proceed_status ();
453:
454: fi = get_frame_info (frame);
455: sal = find_pc_line (fi.pc, 0);
456: sal.pc = fi.pc;
457: set_momentary_breakpoint (sal, frame);
458:
459: /* Find the function we will return from. */
460:
461: fi = get_frame_info (fi.next_frame);
462: function = find_pc_function (fi.pc);
463:
464: if (from_tty)
465: {
466: printf ("Run till exit from ");
467: print_selected_frame ();
468: }
469:
470: proceed (-1, -1, 0);
471:
472: if (stop_breakpoint == -3 && function != 0)
473: {
474: struct type *value_type;
475: register value val;
476:
477: value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
478: if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
479: return;
480:
481: val = value_being_returned (value_type, stop_registers);
482: printf ("Value returned is $%d = ", record_latest_value (val));
483: value_print (val, stdout, 0);
484: putchar ('\n');
485: }
486: }
487:
488: static void
489: program_info ()
490: {
491: if (inferior_pid == 0)
492: {
493: printf ("The program being debugged is not being run.\n");
494: return;
495: }
496:
497: printf ("Program being debugged is in process %d, stopped at 0x%x.\n",
498: inferior_pid, stop_pc);
499: if (stop_step)
500: printf ("It stopped after being stepped.\n");
501: else if (stop_breakpoint)
502: printf ("It stopped at breakpoint %d.\n", stop_breakpoint);
503: else if (stop_signal)
504: printf ("It stopped with signal %d (%s).\n",
505: stop_signal, sys_siglist[stop_signal]);
506:
507: printf ("\nType \"info stack\" or \"info reg\" for more information.\n");
508: }
509:
510: static void
511: environment_info (var)
512: char *var;
513: {
514: if (var)
515: {
516: register char *val = get_in_environ (inferior_environ, var);
517: if (val)
518: printf ("%s = %s\n", var, val);
519: else
520: printf ("Environment variable \"%s\" not defined.\n", var);
521: }
522: else
523: {
524: register char **vector = environ_vector (inferior_environ);
525: while (*vector)
526: printf ("%s\n", *vector++);
527: }
528: }
529:
530: static void
531: set_environment_command (arg)
532: char *arg;
533: {
534: register char *p, *val, *var;
535:
536: if (arg == 0)
537: error_no_arg ("environment variable and value");
538:
539: p = (char *) index (arg, '=');
540: val = (char *) index (arg, ' ');
541: if (p != 0 && val != 0)
542: p = arg + min (p - arg, val - arg);
543: else if (val != 0 && p == 0)
544: p = val;
545:
546: if (p == 0)
547: error ("Space or \"=\" must separate variable name and its value");
548: if (p[1] == 0)
549: error_no_arg ("value for the variable");
550: if (p == arg)
551: error_no_arg ("environment variable to set");
552:
553: val = p + 1;
554: while (*val == ' ' || *val == '\t') val++;
555: while (p != arg && (p[-1] == ' ' || p[-1] == '\t')) p--;
556:
557: var = savestring (arg, p - arg);
558: set_in_environ (inferior_environ, var, val);
559: free (var);
560: }
561:
562: static void
563: unset_environment_command (var)
564: char *var;
565: {
566: if (var == 0)
567: error_no_arg ("environment variable");
568:
569: unset_in_environ (inferior_environ, var);
570: }
571:
572: /* Read an integer from debugged memory, given address and number of bytes. */
573:
574: read_memory_integer (memaddr, len)
575: CORE_ADDR memaddr;
576: int len;
577: {
578: char cbuf;
579: short sbuf;
580: int ibuf;
581: long lbuf;
582:
583: if (len == sizeof (char))
584: {
585: read_memory (memaddr, &cbuf, len);
586: return cbuf;
587: }
588: if (len == sizeof (short))
589: {
590: read_memory (memaddr, &sbuf, len);
591: return sbuf;
592: }
593: if (len == sizeof (int))
594: {
595: read_memory (memaddr, &ibuf, len);
596: return ibuf;
597: }
598: if (len == sizeof (lbuf))
599: {
600: read_memory (memaddr, &lbuf, len);
601: return lbuf;
602: }
603: error ("Cannot handle integers of %d bytes.", len);
604: }
605:
606: CORE_ADDR
607: read_pc ()
608: {
609: return (CORE_ADDR) read_register (PC_REGNUM);
610: }
611:
612: write_pc (val)
613: CORE_ADDR val;
614: {
615: write_register (PC_REGNUM, (long) val);
616: }
617:
618: char *reg_names[] = REGISTER_NAMES;
619:
620: static void
621: registers_info (addr_exp)
622: char *addr_exp;
623: {
624: register int i;
625: int regnum;
626:
627: if (addr_exp)
628: {
629: if (*addr_exp >= '0' && *addr_exp <= '9')
630: regnum = atoi (addr_exp);
631: else
632: {
633: register char *p = addr_exp;
634: if (p[0] == '$')
635: p++;
636: for (regnum = 0; regnum < NUM_REGS; regnum++)
637: if (!strcmp (p, reg_names[regnum]))
638: break;
639: if (regnum == NUM_REGS)
640: error ("%s: invalid register name.", addr_exp);
641: }
642: }
643: else
644: printf ("Reg\tContents\n\n");
645:
646: for (i = 0; i < NUM_REGS; i++)
647: {
648: unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
649: unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
650: REGISTER_TYPE val;
651:
652: if (addr_exp != 0 && i != regnum)
653: continue;
654:
655: /* On machines with lots of registers, pause every 16 lines
656: so user can read the output. */
657: if (addr_exp == 0 && i > 0 && i % 16 == 0)
658: {
659: printf ("--Type Return to print more--");
660: fflush (stdout);
661: read_line ();
662: }
663:
664: /* Get the data in raw format, then convert also to virtual format. */
665: read_relative_register_raw_bytes (i, raw_buffer);
666: REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
667:
668: printf ("%s\t", reg_names[i]);
669:
670: /* If virtual format is floating, print it that way. */
671: if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
672: && ! INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
673: val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout, 0);
674: /* Else if virtual format is too long for printf,
675: print in hex a byte at a time. */
676: else if (REGISTER_VIRTUAL_SIZE (i) > sizeof (long))
677: {
678: register int j;
679: printf ("0x");
680: for (j = 0; j < REGISTER_VIRTUAL_SIZE (i); j++)
681: printf ("%02x", virtual_buffer[j]);
682: }
683: /* Else print as integer in hex and in decimal. */
684: else
685: {
686: long val;
687:
688: bcopy (virtual_buffer, &val, sizeof (long));
689: if (val == 0)
690: printf ("0");
691: else
692: printf ("0x%08x %d", val, val);
693: }
694:
695: /* If register has different raw and virtual formats,
696: print the raw format in hex now. */
697:
698: if (REGISTER_CONVERTIBLE (i))
699: {
700: register int j;
701:
702: printf (" (raw 0x");
703: for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
704: printf ("%02x", raw_buffer[j]);
705: printf (")");
706: }
707: printf ("\n");
708: }
709:
710: printf ("Contents are relative to selected stack frame.\n");
711: }
712:
713: #ifdef ATTACH_DETACH
714: /*
715: * TODO:
716: * Should save/restore the tty state since it might be that the
717: * program to be debugged was started on this tty and it wants
718: * the tty in some state other than what we want. If it's running
719: * on another terminal or without a terminal, then saving and
720: * restoring the tty state is a harmless no-op.
721: */
722:
723: /*
724: * attach_command --
725: * takes a program started up outside of gdb and ``attaches'' to it.
726: * This stops it cold in its tracks and allows us to start tracing it.
727: * For this to work, we must be able to send the process a
728: * signal and we must have the same effective uid as the program.
729: */
730: static void
731: attach_command (args, from_tty)
732: char *args;
733: int from_tty;
734: {
735: char *exec_file;
736: int pid;
737: int remote = 0;
738:
739: dont_repeat();
740:
741: if (!args)
742: error_no_arg ("process-id to attach");
743:
744: while (*args == ' ' || *args == '\t') args++;
745:
746: if (args[0] == '/')
747: remote = 1;
748: else
749: pid = atoi (args);
750:
751: if (inferior_pid)
752: {
753: if (query ("A program is being debugged already. Kill it? "))
754: kill_inferior ();
755: else
756: error ("Inferior not killed.");
757: }
758:
759: exec_file = (char *) get_exec_file (1);
760:
761: if (from_tty)
762: {
763: if (remote)
764: printf ("Attaching remote machine\n");
765: else
766: printf ("Attaching program: %s pid %d\n",
767: exec_file, pid);
768: fflush (stdout);
769: }
770:
771: if (remote)
772: {
773: remote_open (args, from_tty);
774: start_remote ();
775: }
776: else
777: attach_program (pid);
778: }
779:
780: /*
781: * detach_command --
782: * takes a program previously attached to and detaches it.
783: * The program resumes execution and will no longer stop
784: * on signals, etc. We better not have left any breakpoints
785: * in the program or it'll die when it hits one. For this
786: * to work, it may be necessary for the process to have been
787: * previously attached. It *might* work if the program was
788: * started via the normal ptrace (PTRACE_TRACEME).
789: */
790:
791: static void
792: detach_command (args, from_tty)
793: char *args;
794: int from_tty;
795: {
796: int signal = 0;
797:
798: if (!inferior_pid)
799: error ("Not currently tracing a program\n");
800: if (from_tty)
801: {
802: char *exec_file = (char *)get_exec_file (0);
803: if (exec_file == 0)
804: exec_file = "";
805: printf ("Detaching program: %s pid %d\n",
806: exec_file, inferior_pid);
807: fflush (stdout);
808: }
809: if (args)
810: signal = atoi (args);
811:
812: detach (signal);
813: inferior_pid = 0;
814: }
815: #endif /* ATTACH_DETACH */
816:
817: static
818: initialize ()
819: {
820: add_com ("tty", class_run, tty_command,
821: "Set terminal for future runs of program being debugged.");
822:
823: add_com ("set-args", class_run, set_args_command,
824: "Specify arguments to give program being debugged when it is started.\n\
825: Follow this command with any number of args, to be passed to the program.");
826:
827: add_info ("environment", environment_info,
828: "The environment to give the program, or one variable's value.\n\
829: With an argument VAR, prints the value of environment variable VAR to\n\
830: give the program being debugged. With no arguments, prints the entire\n\
831: environment to be given to the program.");
832:
833: add_com ("unset-environment", class_run, unset_environment_command,
834: "Cancel environment variable VAR for the program.\n\
835: This does not affect the program until the next \"run\" command.");
836: add_com ("set-environment", class_run, set_environment_command,
837: "Set environment variable value to give the program.\n\
838: Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
839: VALUES of environment variables are uninterpreted strings.\n\
840: This does not affect the program until the next \"run\" command.");
841:
842: #ifdef ATTACH_DETACH
843: add_com ("attach", class_run, attach_command,
844: "Attach to a process that was started up outside of GDB.\n\
845: To do this, you must have permission to send the process a signal.\n\
846: And it must have the same effective uid as the debugger.\n\n\
847: Before using \"attach\", you must use the \"exec-file\" command\n\
848: to specify the program running in the process,\n\
849: and the \"symbol-file\" command to load its symbol table.");
850: add_com ("detach", class_run, detach_command,
851: "Detach the process previously attached.\n\
852: The process is no longer traced and continues its execution.");
853: #endif /* ATTACH_DETACH */
854:
855: add_com ("signal", class_run, signal_command,
856: "Continue program giving it signal number SIGNUMBER.");
857:
858: add_com ("stepi", class_run, stepi_command,
859: "Step one instruction exactly.\n\
860: Argument N means do this N times (or till program stops for another reason).");
861: add_com_alias ("si", "stepi", class_alias, 0);
862:
863: add_com ("nexti", class_run, nexti_command,
864: "Step one instruction, but proceed through subroutine calls.\n\
865: Argument N means do this N times (or till program stops for another reason).");
866: add_com_alias ("ni", "nexti", class_alias, 0);
867:
868: add_com ("finish", class_run, finish_command,
869: "Execute until selected stack frame returns.\n\
870: Upon return, the value returned is printed and put in the value history.");
871:
872: add_com ("next", class_run, next_command,
873: "Step program, proceeding through subroutine calls.\n\
874: Like the \"step\" command as long as subroutine calls do not happen;\n\
875: when they do, the call is treated as one instruction.\n\
876: Argument N means do this N times (or till program stops for another reason).");
877: add_com_alias ("n", "next", class_run, 1);
878:
879: add_com ("step", class_run, step_command,
880: "Step program until it reaches a different source line.\n\
881: Argument N means do this N times (or till program stops for another reason).");
882: add_com_alias ("s", "step", class_run, 1);
883:
884: add_com ("jump", class_run, jump_command,
885: "Continue program being debugged at specified line or address.\n\
886: Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
887: for an address to start at.");
888:
889: add_com ("cont", class_run, cont_command,
890: "Continue program being debugged, after signal or breakpoint.\n\
891: If proceeding from breakpoint, a number N may be used as an argument:\n\
892: then the same breakpoint won't break until the Nth time it is reached.");
893: add_com_alias ("c", "cont", class_run, 1);
894:
895: add_com ("run", class_run, run_command,
896: "Start debugged program. You may specify arguments to give it.\n\
897: Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
898: Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
899: With no arguments, uses arguments last specified (with \"run\" or \"set-args\".\n\
900: To cancel previous arguments and run with no arguments,\n\
901: use \"set-args\" without arguments.");
902: add_com_alias ("r", "run", class_run, 1);
903:
904: add_info ("registers", registers_info,
905: "List of registers and their contents, for selected stack frame.\n\
906: Register name as argument means describe only that register.");
907:
908: add_info ("program", program_info,
909: "Execution status of the program.");
910:
911: inferior_args = savestring (" ", 1); /* By default, no args. */
912: inferior_environ = make_environ ();
913: init_environ (inferior_environ);
914: }
915:
916: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.