![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to infrun.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 infrun.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* Start and stop the 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 "param.h"
24: #include "symtab.h"
25: #include "frame.h"
26: #include "inferior.h"
27: #include "wait.h"
28:
29: #include <stdio.h>
30: #include <signal.h>
31: #include <a.out.h>
32: #include <sys/file.h>
33:
34: #ifdef UMAX_PTRACE
35: #include <sys/param.h>
36: #include <sys/ptrace.h>
37: #endif UMAX_PTRACE
38:
39: extern char *sys_siglist[];
40: extern int errno;
41:
42: /* Tables of how to react to signals; the user sets them. */
43:
44: static char signal_stop[NSIG];
45: static char signal_print[NSIG];
46: static char signal_program[NSIG];
47:
48: /* Nonzero if breakpoints are now inserted in the inferior. */
49:
50: static int breakpoints_inserted;
51:
52: /* Function inferior was in as of last step command. */
53:
54: static struct symbol *step_start_function;
55:
56: /* This is the sequence of bytes we insert for a breakpoint. */
57:
58: static char break_insn[] = BREAKPOINT;
59:
60: /* Nonzero => address for special breakpoint for resuming stepping. */
61:
62: static CORE_ADDR step_resume_break_address;
63:
64: /* Original contents of the byte where the special breakpoint is. */
65:
66: static char step_resume_break_shadow[sizeof break_insn];
67:
68: /* Nonzero means the special breakpoint is a duplicate
69: so it has not itself been inserted. */
70:
71: static int step_resume_break_duplicate;
72:
73: /* Nonzero if we are expecting a trace trap and should proceed from it.
74: 2 means expecting 2 trace traps and should continue both times.
75: That occurs when we tell sh to exec the program: we will get
76: a trap after the exec of sh and a second when the program is exec'd. */
77:
78: static int trap_expected;
79:
80: /* Nonzero if the next time we try to continue the inferior, it will
81: step one instruction and generate a spurious trace trap.
82: This is used to compensate for a bug in HP-UX. */
83:
84: static int trap_expected_after_continue;
85:
86: /* Nonzero means expecting a trace trap
87: and should stop the inferior and return silently when it happens. */
88:
89: static int stop_after_trap;
90:
91: /* Nonzero means expecting a trace trap due to attaching to a process. */
92:
93: static int stop_after_attach;
94:
95: /* Nonzero if pc has been changed by the debugger
96: since the inferior stopped. */
97:
98: int pc_changed;
99:
100: /* Nonzero if debugging a remote machine via a serial link or ethernet. */
101:
102: int remote_debugging;
103:
104: /* Save register contents here when about to pop a stack dummy frame. */
105:
106: char stop_registers[REGISTER_BYTES];
107:
108: /* Nonzero if program stopped due to error trying to insert breakpoints. */
109:
110: static int breakpoints_failed;
111:
112: /* Nonzero if inferior is in sh before our program got exec'd. */
113:
114: static int running_in_shell;
115:
116: /* Nonzero after stop if current stack frame should be printed. */
117:
118: static int stop_print_frame;
119:
120: static void insert_step_breakpoint ();
121: static void remove_step_breakpoint ();
122: static void wait_for_inferior ();
123: static void normal_stop ();
124:
125: START_FILE
126:
127: /* Clear out all variables saying what to do when inferior is continued.
128: First do this, then set the ones you want, then call `proceed'. */
129:
130: void
131: clear_proceed_status ()
132: {
133: trap_expected = 0;
134: step_range_start = 0;
135: step_range_end = 0;
136: step_frame = 0;
137: step_over_calls = -1;
138: step_resume_break_address = 0;
139: stop_after_trap = 0;
140: stop_after_attach = 0;
141:
142: /* Discard any remaining commands left by breakpoint we had stopped at. */
143: clear_breakpoint_commands ();
144: }
145:
146: /* Basic routine for continuing the program in various fashions.
147:
148: ADDR is the address to resume at, or -1 for resume where stopped.
149: SIGNAL is the signal to give it, or 0 for none,
150: or -1 for act according to how it stopped.
151: STEP is nonzero if should trap after one instruction.
152: -1 means return after that and print nothing.
153: You should probably set various step_... variables
154: before calling here, if you are stepping.
155:
156: You should call clear_proceed_status before calling proceed. */
157:
158: void
159: proceed (addr, signal, step)
160: CORE_ADDR addr;
161: int signal;
162: int step;
163: {
164: int oneproc = 0;
165:
166: if (step > 0)
167: step_start_function = find_pc_function (read_pc ());
168: if (step < 0)
169: stop_after_trap = 1;
170:
171: if (addr == -1)
172: {
173: /* If there is a breakpoint at the address we will resume at,
174: step one instruction before inserting breakpoints
175: so that we do not stop right away. */
176:
177: if (!pc_changed && breakpoint_here_p (read_pc ()))
178: oneproc = 1;
179: }
180: else
181: write_register (PC_REGNUM, addr);
182:
183: if (trap_expected_after_continue)
184: {
185: /* If (step == 0), a trap will be automatically generated after
186: the first instruction is executed. Force step one
187: instruction to clear this condition. This should not occur
188: if step is nonzero, but it is harmless in that case. */
189: oneproc = 1;
190: trap_expected_after_continue = 0;
191: }
192:
193: if (oneproc)
194: /* We will get a trace trap after one instruction.
195: Continue it automatically and insert breakpoints then. */
196: trap_expected = 1;
197: else
198: {
199: int temp = insert_breakpoints ();
200: if (temp)
201: {
202: print_sys_errmsg ("ptrace", temp);
203: error ("Cannot insert breakpoints.\n\
204: The same program may be running in another process.");
205: }
206: breakpoints_inserted = 1;
207: }
208:
209: /* Install inferior's terminal modes. */
210: terminal_inferior ();
211:
212: if (signal >= 0)
213: stop_signal = signal;
214: /* If this signal should not be seen by program,
215: give it zero. Used for debugging signals. */
216: else if (stop_signal < NSIG && !signal_program[stop_signal])
217: stop_signal= 0;
218:
219: /* Resume inferior. */
220: resume (oneproc || step, stop_signal);
221:
222: /* Wait for it to stop (if not standalone)
223: and in any case decode why it stopped, and act accordingly. */
224:
225: wait_for_inferior ();
226: normal_stop ();
227: }
228:
229: /* Writing the inferior pc as a register calls this function
230: to inform infrun that the pc has been set in the debugger. */
231:
232: writing_pc (val)
233: CORE_ADDR val;
234: {
235: stop_pc = val;
236: pc_changed = 1;
237: }
238:
239: /* Start an inferior process for the first time.
240: Actually it was started by the fork that created it,
241: but it will have stopped one instruction after execing sh.
242: Here we must get it up to actual execution of the real program. */
243:
244: start_inferior ()
245: {
246: /* We will get a trace trap after one instruction.
247: Continue it automatically. Eventually (after shell does an exec)
248: it will get another trace trap. Then insert breakpoints and continue. */
249: trap_expected = 2;
250: running_in_shell = 0; /* Set to 1 at first SIGTRAP, 0 at second. */
251: trap_expected_after_continue = 0;
252: breakpoints_inserted = 0;
253: mark_breakpoints_out ();
254:
255: /* Set up the "saved terminal modes" of the inferior
256: based on what modes we are starting it with. */
257: terminal_init_inferior ();
258:
259: /* Install inferior's terminal modes. */
260: terminal_inferior ();
261:
262: if (remote_debugging)
263: {
264: trap_expected = 0;
265: fetch_inferior_registers();
266: set_current_frame (read_register(FP_REGNUM));
267: stop_frame = get_current_frame();
268: inferior_pid = 3;
269: if (insert_breakpoints())
270: fatal("Can't insert breakpoints");
271: breakpoints_inserted = 1;
272: proceed(-1, -1, 0);
273: }
274: else
275: {
276: wait_for_inferior ();
277: normal_stop ();
278: }
279: }
280:
281: /* Start remote-debugging of a machine over a serial link. */
282:
283: void
284: start_remote ()
285: {
286: clear_proceed_status ();
287: running_in_shell = 0;
288: trap_expected = 0;
289: inferior_pid = 3;
290: breakpoints_inserted = 0;
291: mark_breakpoints_out ();
292: wait_for_inferior ();
293: normal_stop();
294: }
295:
296: #ifdef ATTACH_DETACH
297:
298: /* Attach to process PID, then initialize for debugging it
299: and wait for the trace-trap that results from attaching. */
300:
301: void
302: attach_program (pid)
303: int pid;
304: {
305: attach (pid);
306: inferior_pid = pid;
307:
308: mark_breakpoints_out ();
309: terminal_init_inferior ();
310: clear_proceed_status ();
311: stop_after_attach = 1;
312: /*proceed (-1, 0, -2);*/
313: wait_for_inferior ();
314: normal_stop ();
315: }
316: #endif /* ATTACH_DETACH */
317:
318: /* Wait for control to return from inferior to debugger.
319: If inferior gets a signal, we may decide to start it up again
320: instead of returning. That is why there is a loop in this function.
321: When this function actually returns it means the inferior
322: should be left stopped and GDB should read more commands. */
323:
324: static void
325: wait_for_inferior ()
326: {
327: register int pid;
328: WAITTYPE w;
329: CORE_ADDR pc;
330: int tem;
331: int another_trap;
332: int random_signal;
333: CORE_ADDR stop_sp;
334: int stop_step_resume_break;
335: int newmisc;
336: int newfun_pc;
337: struct symbol *newfun;
338: struct symtab_and_line sal;
339: int prev_pc;
340:
341: prev_pc = read_pc ();
342:
343: while (1)
344: {
345: if (remote_debugging)
346: remote_wait (&w);
347: else
348: {
349: pid = wait (&w);
350: if (pid != inferior_pid)
351: continue;
352: }
353:
354: pc_changed = 0;
355: fetch_inferior_registers ();
356: stop_pc = read_pc ();
357: set_current_frame (read_register (FP_REGNUM));
358: stop_frame = get_current_frame ();
359: stop_sp = read_register (SP_REGNUM);
360: another_trap = 0;
361: stop_breakpoint = 0;
362: stop_step = 0;
363: stop_stack_dummy = 0;
364: stop_print_frame = 1;
365: stop_step_resume_break = 0;
366: random_signal = 0;
367: breakpoints_failed = 0;
368:
369: /* Look at the cause of the stop, and decide what to do.
370: The alternatives are:
371: 1) break; to really stop and return to the debugger,
372: 2) drop through to start up again
373: (set another_trap to 1 to single step once)
374: 3) set random_signal to 1, and the decision between 1 and 2
375: will be made according to the signal handling tables. */
376:
377: if (WIFEXITED (w))
378: {
379: terminal_ours_for_output ();
380: if (WRETCODE (w))
381: printf ("\nProgram exited with code 0%o.\n", WRETCODE (w));
382: else
383: printf ("\nProgram exited normally.\n");
384: fflush (stdout);
385: inferior_died ();
386: stop_print_frame = 0;
387: break;
388: }
389: else if (!WIFSTOPPED (w))
390: {
391: kill_inferior ();
392: stop_print_frame = 0;
393: stop_signal = WTERMSIG (w);
394: terminal_ours_for_output ();
395: printf ("\nProgram terminated with signal %d, %s\n",
396: stop_signal,
397: stop_signal < NSIG
398: ? sys_siglist[stop_signal]
399: : "(undocumented)");
400: printf ("The inferior process no longer exists.\n");
401: fflush (stdout);
402: break;
403: }
404: else
405: {
406: stop_signal = WSTOPSIG (w);
407:
408: /* First, distinguish signals caused by the debugger from signals
409: that have to do with the program's own actions.
410: Note that breakpoint insns may cause SIGTRAP or SIGILL
411: or SIGEMT, depending on the operating system version.
412: Here we detect when a SIGILL or SIGEMT is really a breakpoint
413: and change it to SIGTRAP. */
414:
415: if (stop_signal == SIGTRAP
416: || (breakpoints_inserted &&
417: (stop_signal == SIGILL
418: || stop_signal == SIGEMT))
419: || stop_after_attach)
420: {
421: if (stop_signal == SIGTRAP && stop_after_trap)
422: {
423: stop_print_frame = 0;
424: break;
425: }
426: if (stop_after_attach)
427: break;
428: /* Don't even think about breakpoints
429: if still running the shell that will exec the program
430: or if just proceeded over a breakpoint. */
431: if (stop_signal == SIGTRAP && trap_expected)
432: stop_breakpoint = 0;
433: else
434: /* See if there is a breakpoint at the current PC. */
435: #if DECR_PC_AFTER_BREAK
436: /* Notice the case of stepping through a jump
437: that leads just after a breakpoint.
438: Don't confuse that with hitting the breakpoint.
439: What we check for is that 1) stepping is going on
440: and 2) the pc before the last insn does not match
441: the address of the breakpoint before the current pc. */
442: if (!(prev_pc != stop_pc - DECR_PC_AFTER_BREAK
443: && step_range_end && !step_resume_break_address))
444: #endif /* DECR_PC_AFTER_BREAK not zero */
445: {
446: select_frame (stop_frame, 0); /* For condition exprs. */
447: stop_breakpoint = breakpoint_stop_status (stop_pc, stop_frame);
448: /* Following in case break condition called a function. */
449: stop_print_frame = 1;
450: if (stop_breakpoint && DECR_PC_AFTER_BREAK)
451: {
452: stop_pc -= DECR_PC_AFTER_BREAK;
453: write_register (PC_REGNUM, stop_pc);
454: pc_changed = 0;
455: }
456: }
457: /* See if we stopped at the special breakpoint for
458: stepping over a subroutine call. */
459: if (stop_pc - DECR_PC_AFTER_BREAK == step_resume_break_address)
460: {
461: stop_step_resume_break = 1;
462: if (DECR_PC_AFTER_BREAK)
463: {
464: stop_pc -= DECR_PC_AFTER_BREAK;
465: write_register (PC_REGNUM, stop_pc);
466: pc_changed = 0;
467: }
468: }
469:
470: if (stop_signal == SIGTRAP)
471: random_signal
472: = !(stop_breakpoint || trap_expected
473: || stop_step_resume_break
474: || (stop_sp INNER_THAN stop_pc && stop_pc INNER_THAN stop_frame)
475: || (step_range_end && !step_resume_break_address));
476: else
477: {
478: random_signal
479: = !(stop_breakpoint || stop_step_resume_break);
480: if (!random_signal)
481: stop_signal = SIGTRAP;
482: }
483: }
484: else
485: random_signal = 1;
486:
487: /* For the program's own signals, act according to
488: the signal handling tables. */
489:
490: if (random_signal
491: && !(running_in_shell && stop_signal == SIGSEGV))
492: {
493: /* Signal not for debugging purposes. */
494: int printed = 0;
495:
496: if (stop_signal >= NSIG
497: || signal_print[stop_signal])
498: {
499: printed = 1;
500: terminal_ours_for_output ();
501: printf ("\nProgram received signal %d, %s\n",
502: stop_signal,
503: stop_signal < NSIG
504: ? sys_siglist[stop_signal]
505: : "(undocumented)");
506: fflush (stdout);
507: }
508: if (stop_signal >= NSIG
509: || signal_stop[stop_signal])
510: break;
511: /* If not going to stop, give terminal back
512: if we took it away. */
513: else if (printed)
514: terminal_inferior ();
515: }
516:
517: /* Handle cases caused by hitting a breakpoint. */
518:
519: if (!random_signal
520: && (stop_breakpoint || stop_step_resume_break))
521: {
522: /* Does a breakpoint want us to stop? */
523: if (stop_breakpoint && stop_breakpoint != -1)
524: {
525: /* 0x1000000 is set in stop_breakpoint as returned by
526: breakpoint_status_p to indicate a silent breakpoint. */
527: if (stop_breakpoint > 0 && stop_breakpoint & 0x1000000)
528: {
529: stop_breakpoint &= ~0x1000000;
530: stop_print_frame = 0;
531: }
532: break;
533: }
534: /* But if we have hit the step-resumption breakpoint,
535: remove it. It has done its job getting us here. */
536: if (stop_step_resume_break
537: && (step_frame == 0 || stop_frame == step_frame))
538: {
539: remove_step_breakpoint ();
540: step_resume_break_address = 0;
541: }
542: /* Otherwise, must remove breakpoints and single-step
543: to get us past the one we hit. */
544: else
545: {
546: remove_breakpoints ();
547: remove_step_breakpoint ();
548: breakpoints_inserted = 0;
549: another_trap = 1;
550: }
551:
552: /* We come here if we hit a breakpoint but should not
553: stop for it. Possibly we also were stepping
554: and should stop for that. So fall through and
555: test for stepping. But, if not stepping,
556: do not stop. */
557: }
558:
559: /* If this is the breakpoint at the end of a stack dummy,
560: just stop silently. */
561: if (stop_sp INNER_THAN stop_pc && stop_pc INNER_THAN stop_frame)
562: {
563: stop_print_frame = 0;
564: stop_stack_dummy = 1;
565: #ifdef HP9K320
566: trap_expected_after_continue = 1;
567: #endif
568: break;
569: }
570:
571: if (step_resume_break_address)
572: /* Having a step-resume breakpoint overrides anything
573: else having to do with stepping commands until
574: that breakpoint is reached. */
575: ;
576: /* If stepping through a line, keep going if still within it. */
577: else if (!random_signal
578: && step_range_end
579: && stop_pc >= step_range_start
580: && stop_pc < step_range_end)
581: {
582: /* Don't step through the return from a function
583: unless that is the first instruction stepped through. */
584: if (ABOUT_TO_RETURN (stop_pc))
585: {
586: stop_step = 1;
587: break;
588: }
589: }
590:
591: /* We stepped out of the stepping range. See if that was due
592: to a subroutine call that we should proceed to the end of. */
593: else if (!random_signal && step_range_end)
594: {
595: newfun = find_pc_function (stop_pc);
596: newmisc = -1;
597: if (newfun)
598: {
599: newfun_pc = BLOCK_START (SYMBOL_BLOCK_VALUE (newfun))
600: + FUNCTION_START_OFFSET;
601: }
602: else
603: {
604: newmisc = find_pc_misc_function (stop_pc);
605: if (newmisc >= 0)
606: newfun_pc = misc_function_vector[newmisc].address
607: + FUNCTION_START_OFFSET;
608: else newfun_pc = 0;
609: }
610: if (stop_pc == newfun_pc
611: && (step_over_calls > 0 || (step_over_calls && newfun == 0)))
612: {
613: /* A subroutine call has happened. */
614: /* Set a special breakpoint after the return */
615: step_resume_break_address = SAVED_PC_AFTER_CALL (stop_frame);
616: step_resume_break_duplicate
617: = breakpoint_here_p (step_resume_break_address);
618: if (breakpoints_inserted)
619: insert_step_breakpoint ();
620: }
621: /* Subroutine call with source code we should not step over.
622: Do step to the first line of code in it. */
623: else if (stop_pc == newfun_pc && step_over_calls)
624: {
625: SKIP_PROLOGUE (newfun_pc);
626: sal = find_pc_line (newfun_pc, 0);
627: /* Use the step_resume_break to step until
628: the end of the prologue, even if that involves jumps
629: (as it seems to on the vax under 4.2). */
630: /* If the prologue ends in the middle of a source line,
631: continue to the end of that source line.
632: Otherwise, just go to end of prologue. */
633: if (sal.end && sal.pc != newfun_pc)
634: newfun_pc = sal.end;
635:
636: if (newfun_pc == stop_pc)
637: /* We are already there: stop now. */
638: stop_step = 1;
639: else
640: /* Put the step-breakpoint there and go until there. */
641: {
642: step_resume_break_address = newfun_pc;
643:
644: step_resume_break_duplicate
645: = breakpoint_here_p (step_resume_break_address);
646: if (breakpoints_inserted)
647: insert_step_breakpoint ();
648: /* Do not specify what the fp should be when we stop
649: since on some machines the prologue
650: is where the new fp value is established. */
651: step_frame = 0;
652: /* And make sure stepping stops right away then. */
653: step_range_end = step_range_start;
654: }
655: }
656: /* No subroutince call; stop now. */
657: else
658: {
659: stop_step = 1;
660: break;
661: }
662: }
663: }
664:
665: /* Save the pc before execution, to compare with pc after stop. */
666: prev_pc = read_pc ();
667:
668: /* If we did not do break;, it means we should keep
669: running the inferior and not return to debugger. */
670:
671: /* If trap_expected is 2, it means continue once more
672: and insert breakpoints at the next trap.
673: If trap_expected is 1 and the signal was SIGSEGV, it means
674: the shell is doing some memory allocation--just resume it
675: with SIGSEGV.
676: Otherwise insert breakpoints now, and possibly single step. */
677:
678: if (trap_expected > 1)
679: {
680: trap_expected--;
681: running_in_shell = 1;
682: resume (0, 0);
683: }
684: else if (running_in_shell && stop_signal == SIGSEGV)
685: {
686: resume (0, SIGSEGV);
687: }
688: else
689: {
690: /* Here, we are not awaiting another exec to get
691: the program we really want to debug.
692: Insert breakpoints now, unless we are trying
693: to one-proceed past a breakpoint. */
694: running_in_shell = 0;
695: if (!breakpoints_inserted && !another_trap)
696: {
697: insert_step_breakpoint ();
698: breakpoints_failed = insert_breakpoints ();
699: if (breakpoints_failed)
700: break;
701: breakpoints_inserted = 1;
702: }
703:
704: trap_expected = another_trap;
705:
706: if (stop_signal == SIGTRAP)
707: stop_signal = 0;
708:
709: resume ((step_range_end && !step_resume_break_address)
710: || trap_expected,
711: stop_signal);
712: }
713: }
714: }
715:
716: /* Here to return control to GDB when the inferior stops for real.
717: Print appropriate messages, remove breakpoints, give terminal our modes.
718:
719: RUNNING_IN_SHELL nonzero means the shell got a signal before
720: exec'ing the program we wanted to run.
721: STOP_PRINT_FRAME nonzero means print the executing frame
722: (pc, function, args, file, line number and line text).
723: BREAKPOINTS_FAILED nonzero means stop was due to error
724: attempting to insert breakpoints. */
725:
726: static void
727: normal_stop ()
728: {
729: if (breakpoints_failed)
730: {
731: terminal_ours_for_output ();
732: print_sys_errmsg ("ptrace", breakpoints_failed);
733: printf ("Stopped; cannot insert breakpoints.\n\
734: The same program may be running in another process.\n");
735: }
736:
737: if (inferior_pid)
738: remove_step_breakpoint ();
739:
740: if (inferior_pid && breakpoints_inserted)
741: if (remove_breakpoints ())
742: {
743: terminal_ours_for_output ();
744: printf ("Cannot remove breakpoints because program is no longer writable.\n\
745: It must be running in another process.\n\
746: Further execution is probably impossible.\n");
747: }
748:
749: breakpoints_inserted = 0;
750:
751: /* Delete the breakpoint we stopped at, if it wants to be deleted.
752: Delete any breakpoint that is to be deleted at the next stop. */
753:
754: breakpoint_auto_delete (stop_breakpoint);
755:
756: /* If an auto-display called a function and that got a signal,
757: delete that auto-display to avoid an infinite recursion. */
758:
759: delete_current_display ();
760:
761: if (step_multi && stop_step)
762: return;
763:
764: terminal_ours ();
765:
766: if (running_in_shell)
767: {
768: if (stop_signal == SIGSEGV)
769: {
770: char *exec_file = (char *) get_exec_file (1);
771:
772: if (access (exec_file, X_OK) != 0)
773: printf ("The file \"%s\" is not executable.\n", exec_file);
774: else
775: printf ("\
776: You have just encountered a bug in \"sh\". GDB starts your program\n\
777: by running \"sh\" with a command to exec your program.\n\
778: This is so that \"sh\" will process wildcards and I/O redirection.\n\
779: This time, \"sh\" crashed.\n\
780: \n\
781: One known bug in \"sh\" bites when the environment takes up a lot of space.\n\
782: Try \"info env\" to see the environment; then use \"unset-env\" to kill\n\
783: some variables whose values are large; then do \"run\" again.\n\
784: \n\
785: If that works, you might want to put those \"unset-env\" commands\n\
786: into a \".gdbinit\" file in this directory so they will happen every time.\n");
787: }
788: /* Don't confuse user with his program's symbols on sh's data. */
789: stop_print_frame = 0;
790: }
791:
792: if (inferior_pid == 0)
793: return;
794:
795: /* Select innermost stack frame except on return from a stack dummy routine,
796: or if the program has exited. */
797: if (!stop_stack_dummy)
798: {
799: select_frame (stop_frame, 0);
800:
801: if (stop_print_frame)
802: {
803: if (stop_breakpoint > 0)
804: printf ("\nBpt %d, ", stop_breakpoint);
805: print_sel_frame (stop_step
806: && step_frame == stop_frame
807: && step_start_function == find_pc_function (stop_pc));
808: /* Display the auto-display expressions. */
809: do_displays ();
810: }
811: }
812:
813: /* Save the function value return registers
814: We might be about to restore their previous contents. */
815: read_register_bytes (0, stop_registers, REGISTER_BYTES);
816:
817: if (stop_stack_dummy)
818: {
819: /* Pop the empty frame that contains the stack dummy. */
820: POP_FRAME;
821: select_frame (read_register (FP_REGNUM), 0);
822: }
823: }
824:
825: static void
826: insert_step_breakpoint ()
827: {
828: if (step_resume_break_address && !step_resume_break_duplicate)
829: {
830: read_memory (step_resume_break_address,
831: step_resume_break_shadow, sizeof break_insn);
832: write_memory (step_resume_break_address,
833: break_insn, sizeof break_insn);
834: }
835: }
836:
837: static void
838: remove_step_breakpoint ()
839: {
840: if (step_resume_break_address && !step_resume_break_duplicate)
841: write_memory (step_resume_break_address, step_resume_break_shadow,
842: sizeof break_insn);
843: }
844:
845: /* Specify how various signals in the inferior should be handled. */
846:
847: static void
848: handle_command (args, from_tty)
849: char *args;
850: int from_tty;
851: {
852: register char *p = args;
853: int signum;
854: register int digits, wordlen;
855:
856: if (!args)
857: error_no_arg ("signal to handle");
858:
859: while (*p)
860: {
861: /* Find the end of the next word in the args. */
862: for (wordlen = 0; p[wordlen] && p[wordlen] != ' ' && p[wordlen] != '\t';
863: wordlen++);
864: for (digits = 0; p[digits] >= '0' && p[digits] <= '9'; digits++);
865:
866: /* If it is all digits, it is signal number to operate on. */
867: if (digits == wordlen)
868: {
869: signum = atoi (p);
870: if (signum == SIGTRAP || signum == SIGINT)
871: {
872: if (!query ("Signal %d is used by the debugger.\nAre you sure you want to change it? ", signum))
873: error ("Not confirmed.");
874: }
875: }
876: else if (signum == 0)
877: error ("First argument is not a signal number.");
878:
879: /* Else, if already got a signal number, look for flag words
880: saying what to do for it. */
881: else if (!strncmp (p, "stop", wordlen))
882: {
883: signal_stop[signum] = 1;
884: signal_print[signum] = 1;
885: }
886: else if (wordlen >= 2 && !strncmp (p, "print", wordlen))
887: signal_print[signum] = 1;
888: else if (wordlen >= 2 && !strncmp (p, "pass", wordlen))
889: signal_program[signum] = 1;
890: else if (!strncmp (p, "ignore", wordlen))
891: signal_program[signum] = 0;
892: else if (wordlen >= 3 && !strncmp (p, "nostop", wordlen))
893: signal_stop[signum] = 0;
894: else if (wordlen >= 4 && !strncmp (p, "noprint", wordlen))
895: {
896: signal_print[signum] = 0;
897: signal_stop[signum] = 0;
898: }
899: else if (wordlen >= 4 && !strncmp (p, "nopass", wordlen))
900: signal_program[signum] = 0;
901: else if (wordlen >= 3 && !strncmp (p, "noignore", wordlen))
902: signal_program[signum] = 1;
903: /* Not a number and not a recognized flag word => complain. */
904: else
905: {
906: p[wordlen] = 0;
907: error ("Unrecognized flag word: \"%s\".", p);
908: }
909:
910: /* Find start of next word. */
911: p += wordlen;
912: while (*p == ' ' || *p == '\t') p++;
913: }
914:
915: if (from_tty)
916: {
917: /* Show the results. */
918: printf ("Number\tStop\tPrint\tPass to program\tDescription\n");
919: printf ("%d\t", signum);
920: printf ("%s\t", signal_stop[signum] ? "Yes" : "No");
921: printf ("%s\t", signal_print[signum] ? "Yes" : "No");
922: printf ("%s\t\t", signal_program[signum] ? "Yes" : "No");
923: printf ("%s\n", sys_siglist[signum]);
924: }
925: }
926:
927: /* Print current contents of the tables set by the handle command. */
928:
929: static void
930: signals_info (signum_exp)
931: char *signum_exp;
932: {
933: register int i;
934: printf ("Number\tStop\tPrint\tPass to program\tDescription\n");
935:
936: if (signum_exp)
937: {
938: i = parse_and_eval_address (signum_exp);
939: printf ("%d\t", i);
940: printf ("%s\t", signal_stop[i] ? "Yes" : "No");
941: printf ("%s\t", signal_print[i] ? "Yes" : "No");
942: printf ("%s\t\t", signal_program[i] ? "Yes" : "No");
943: printf ("%s\n", sys_siglist[i]);
944: return;
945: }
946:
947: printf ("\n");
948: for (i = 0; i < NSIG; i++)
949: {
950: QUIT;
951: if (i > 0 && i % 16 == 0)
952: {
953: printf ("[Type Return to see more]");
954: fflush (stdout);
955: read_line ();
956: }
957: printf ("%d\t", i);
958: printf ("%s\t", signal_stop[i] ? "Yes" : "No");
959: printf ("%s\t", signal_print[i] ? "Yes" : "No");
960: printf ("%s\t\t", signal_program[i] ? "Yes" : "No");
961: printf ("%s\n", sys_siglist[i]);
962: }
963:
964: printf ("\nUse the \"handle\" command to change these tables.\n");
965: }
966:
967: static
968: initialize ()
969: {
970: register int i;
971:
972: add_info ("signals", signals_info,
973: "What debugger does when program gets various signals.\n\
974: Specify a signal number as argument to print info on that signal only.");
975:
976: add_com ("handle", class_run, handle_command,
977: "Specify how to handle a signal.\n\
978: Args are signal number followed by flags.\n\
979: Flags allowed are \"stop\", \"print\", \"pass\",\n\
980: \"nostop\", \"noprint\" or \"nopass\".\n\
981: Print means print a message if this signal happens.\n\
982: Stop means reenter debugger if this signal happens (implies print).\n\
983: Pass means let program see this signal; otherwise program doesn't know.\n\
984: Pass and Stop may be combined.");
985:
986: for (i = 0; i < NSIG; i++)
987: {
988: signal_stop[i] = 1;
989: signal_print[i] = 1;
990: signal_program[i] = 1;
991: }
992:
993: /* Signals caused by debugger's own actions
994: should not be given to the program afterwards. */
995: signal_program[SIGTRAP] = 0;
996: signal_program[SIGINT] = 0;
997:
998: /* Signals that are not errors should not normally enter the debugger. */
999: #ifdef SIGALRM
1000: signal_stop[SIGALRM] = 0;
1001: signal_print[SIGALRM] = 0;
1002: #endif /* SIGALRM */
1003: #ifdef SIGVTALRM
1004: signal_stop[SIGVTALRM] = 0;
1005: signal_print[SIGVTALRM] = 0;
1006: #endif /* SIGVTALRM */
1007: #ifdef SIGPROF
1008: signal_stop[SIGPROF] = 0;
1009: signal_print[SIGPROF] = 0;
1010: #endif /* SIGPROF */
1011: #ifdef SIGCHLD
1012: signal_stop[SIGCHLD] = 0;
1013: signal_print[SIGCHLD] = 0;
1014: #endif /* SIGCHLD */
1015: #ifdef SIGCLD
1016: signal_stop[SIGCLD] = 0;
1017: signal_print[SIGCLD] = 0;
1018: #endif /* SIGCLD */
1019: #ifdef SIGIO
1020: signal_stop[SIGIO] = 0;
1021: signal_print[SIGIO] = 0;
1022: #endif /* SIGIO */
1023: #ifdef SIGURG
1024: signal_stop[SIGURG] = 0;
1025: signal_print[SIGURG] = 0;
1026: #endif /* SIGURG */
1027: }
1028:
1029: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.