![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to breakpoint.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GNU Debugger] / gdb|
Return to breakpoint.c CVS log | Up to [GNU Debugger] / gdb |
1.1 root 1: /* Everything about breakpoints, for GDB.
2: Copyright (C) 1986, 1987 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:
27: #include <stdio.h>
28:
29: /* This is the sequence of bytes we insert for a breakpoint. */
30:
31: static char break_insn[] = BREAKPOINT;
32:
33: /* States of enablement of breakpoint.
34: `temporary' means disable when hit.
35: `once' means delete when hit. */
36:
37: enum enable { disabled, enabled, temporary, delete};
38:
39: struct breakpoint
40: {
41: struct breakpoint *next;
42: /* Number assigned to distinguish breakpoints. */
43: int number;
44: /* Address to break at. */
45: CORE_ADDR address;
46: /* Line number of this address. Redundant. */
47: int line_number;
48: /* Symtab of file of this address. Redundant. */
49: struct symtab *symtab;
50: /* Zero means disabled; remember the info but don't break here. */
51: enum enable enable;
52: /* Number of stops at this breakpoint that should
53: be continued automatically before really stopping. */
54: int ignore_count;
55: /* "Real" contents of byte where breakpoint has been inserted.
56: Valid only when breakpoints are in the program. */
57: char shadow_contents[sizeof break_insn];
58: /* Nonzero if this breakpoint is now inserted. */
59: char inserted;
60: /* Nonzero if this is not the first breakpoint in the list
61: for the given address. */
62: char duplicate;
63: /* Chain of command lines to execute when this breakpoint is hit. */
64: struct command_line *commands;
65: /* Stack depth (frame). If nonzero, break only if fp equals this. */
66: FRAME frame;
67: /* Conditional. Break only if this expression's value is nonzero. */
68: struct expression *cond;
69: };
70:
71: #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
72:
73: /* Chain of all breakpoints defined. */
74:
75: struct breakpoint *breakpoint_chain;
76:
77: /* Number of last breakpoint made. */
78:
79: static int breakpoint_count;
80:
81: /* Default address, symtab and line to put a breakpoint at
82: for "break" command with no arg.
83: if default_breakpoint_valid is zero, the other three are
84: not valid, and "break" with no arg is an error.
85:
86: This set by print_stack_frame, which calls set_default_breakpoint. */
87:
88: int default_breakpoint_valid;
89: CORE_ADDR default_breakpoint_address;
90: struct symtab *default_breakpoint_symtab;
91: int default_breakpoint_line;
92:
93: /* Remaining commands (not yet executed)
94: of last breakpoint hit. */
95:
96: struct command_line *breakpoint_commands;
97:
98: START_FILE
99:
100: extern char *read_line ();
101:
102: static void delete_breakpoint ();
103: void clear_momentary_breakpoints ();
104: void breakpoint_auto_delete ();
105:
106: /* condition N EXP -- set break condition of breakpoint N to EXP. */
107:
108: static void
109: condition_command (arg, from_tty)
110: char *arg;
111: int from_tty;
112: {
113: register struct breakpoint *b;
114: register char *p;
115: register int bnum;
116: register struct expression *expr;
117:
118: if (arg == 0)
119: error_no_arg ("breakpoint number");
120:
121: p = arg;
122: while (*p >= '0' && *p <= '9') p++;
123: bnum = atoi (arg);
124:
125: ALL_BREAKPOINTS (b)
126: if (b->number == bnum)
127: {
128: if (b->cond)
129: free (b->cond);
130: if (*p == 0)
131: {
132: b->cond = 0;
133: if (from_tty)
134: printf ("Breakpoint %d now unconditional.\n", bnum);
135: }
136: else
137: {
138: if (*p != ' ' && *p != '\t')
139: error ("Arguments must be an integer (breakpoint number) and an expression.");
140:
141: /* Find start of expression */
142: while (*p == ' ' || *p == '\t') p++;
143:
144: arg = p;
145: b->cond = (struct expression *) parse_c_1 (&arg, block_for_pc (b->address));
146: }
147: return;
148: }
149:
150: error ("No breakpoint number %d.", bnum);
151: }
152:
153: static void
154: commands_command (arg)
155: char *arg;
156: {
157: register struct breakpoint *b;
158: register char *p, *p1;
159: register int bnum;
160: struct command_line *l;
161:
162: if (arg == 0)
163: error_no_arg ("breakpoint number");
164:
165: /* If we allowed this, we would have problems with when to
166: free the storage, if we change the commands currently
167: being read from. */
168:
169: if (breakpoint_commands)
170: error ("Can't use the \"commands\" command among a breakpoint's commands.");
171:
172: p = arg;
173: if (! (*p >= '0' && *p <= '9'))
174: error ("Argument must be integer (a breakpoint number).");
175:
176: while (*p >= '0' && *p <= '9') p++;
177: if (*p)
178: error ("Unexpected extra arguments following breakpoint number.");
179:
180: bnum = atoi (arg);
181:
182: ALL_BREAKPOINTS (b)
183: if (b->number == bnum)
184: {
185: if (input_from_terminal_p ())
186: printf ("Type commands for when breakpoint %d is hit, one per line.\n\
187: End with a line saying just \"end\".\n", bnum);
188: l = read_command_lines ();
189: free_command_lines (&b->commands);
190: b->commands = l;
191: return;
192: }
193: error ("No breakpoint number %d.", bnum);
194: }
195:
196: /* Called from command loop to execute the commands
197: associated with the breakpoint we just stopped at. */
198:
199: void
200: do_breakpoint_commands ()
201: {
202: while (breakpoint_commands)
203: {
204: execute_command (breakpoint_commands->line, 0);
205: /* If command was "cont", breakpoint_commands is 0 now. */
206: if (breakpoint_commands)
207: breakpoint_commands = breakpoint_commands->next;
208: }
209: clear_momentary_breakpoints ();
210: }
211:
212: /* Used when the program is proceeded, to eliminate any remaining
213: commands attached to the previous breakpoint we stopped at. */
214:
215: void
216: clear_breakpoint_commands ()
217: {
218: breakpoint_commands = 0;
219: breakpoint_auto_delete (0);
220: }
221:
222: /* insert_breakpoints is used when starting or continuing the program.
223: remove_breakpoints is used when the program stops.
224: Both return zero if successful, 1 if could not write the inferior. */
225:
226: int
227: insert_breakpoints ()
228: {
229: register struct breakpoint *b;
230:
231: /* printf ("Inserting breakpoints.\n"); */
232: ALL_BREAKPOINTS (b)
233: if (b->enable != disabled && ! b->inserted && ! b->duplicate)
234: {
235: read_memory (b->address, b->shadow_contents, sizeof break_insn);
236: if (write_memory (b->address, break_insn, sizeof break_insn))
237: return 1;
238: /* printf ("Inserted breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
239: b->address, b->shadow_contents[0], b->shadow_contents[1]); */
240: b->inserted = 1;
241: }
242: return 0;
243: }
244:
245: int
246: remove_breakpoints ()
247: {
248: register struct breakpoint *b;
249:
250: /* printf ("Removing breakpoints.\n"); */
251: ALL_BREAKPOINTS (b)
252: if (b->inserted)
253: {
254: if (write_memory (b->address, b->shadow_contents, sizeof break_insn))
255: return 1;
256: b->inserted = 0;
257: /* printf ("Removed breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
258: b->address, b->shadow_contents[0], b->shadow_contents[1]); */
259: }
260:
261: return 0;
262: }
263:
264: /* Clear the "inserted" flag in all breakpoints.
265: This is done when the inferior is loaded. */
266:
267: int
268: mark_breakpoints_out ()
269: {
270: register struct breakpoint *b;
271:
272: ALL_BREAKPOINTS (b)
273: b->inserted = 0;
274: }
275:
276: /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
277: When continuing from a location with a breakpoint,
278: we actually single step once before calling insert_breakpoints. */
279:
280: int
281: breakpoint_here_p (pc)
282: CORE_ADDR pc;
283: {
284: register struct breakpoint *b;
285:
286: ALL_BREAKPOINTS (b)
287: if (b->enable != disabled && b->address == pc)
288: return 1;
289:
290: return 0;
291: }
292:
293: /* Return 0 if PC is not the address just after a breakpoint,
294: or -1 if breakpoint says do not stop now,
295: or -2 if breakpoint says it has deleted itself and don't stop,
296: or -3 if hit a breakpoint number -3 (delete when program stops),
297: or else the number of the breakpoint,
298: with 0x1000000 added for a silent breakpoint. */
299:
300: int
301: breakpoint_stop_status (pc, frame)
302: CORE_ADDR pc;
303: FRAME frame;
304: {
305: register struct breakpoint *b;
306: register int cont = 0;
307:
308: /* Get the address where the breakpoint would have been. */
309: pc -= DECR_PC_AFTER_BREAK;
310:
311: ALL_BREAKPOINTS (b)
312: if (b->enable != disabled && b->address == pc)
313: {
314: if (b->frame && b->frame != frame)
315: cont = -1;
316: else
317: {
318: int value_zero;
319: if (b->cond)
320: {
321: value_zero = value_zerop (evaluate_expression (b->cond));
322: free_all_values ();
323: }
324: if (b->cond && value_zero)
325: {
326: cont = -1;
327: }
328: else if (b->ignore_count > 0)
329: {
330: b->ignore_count--;
331: cont = -1;
332: }
333: else
334: {
335: if (b->enable == temporary)
336: b->enable = disabled;
337: breakpoint_commands = b->commands;
338: if (breakpoint_commands
339: && !strcmp ("silent", breakpoint_commands->line))
340: {
341: breakpoint_commands = breakpoint_commands->next;
342: return 0x1000000 + b->number;
343: }
344: return b->number;
345: }
346: }
347: }
348:
349: return cont;
350: }
351:
352: static void
353: breakpoint_1 (bnum)
354: int bnum;
355: {
356: register struct breakpoint *b;
357: register struct command_line *l;
358: register struct symbol *sym;
359: CORE_ADDR last_addr = -1;
360:
361: ALL_BREAKPOINTS (b)
362: if (bnum == -1 || bnum == b->number)
363: {
364: printf ("#%-3d %c 0x%08x ", b->number,
365: "nyod"[(int) b->enable],
366: b->address);
367: last_addr = b->address;
368: if (b->symtab)
369: {
370: sym = find_pc_function (b->address);
371: if (sym)
372: printf (" in %s (%s line %d)", SYMBOL_NAME (sym),
373: b->symtab->filename, b->line_number);
374: else
375: printf ("%s line %d", b->symtab->filename, b->line_number);
376: }
377: printf ("\n");
378:
379: if (b->ignore_count)
380: printf ("\tignore next %d hits\n", b->ignore_count);
381: if (b->frame)
382: printf ("\tstop only in stack frame at 0x%x\n", b->frame);
383: if (b->cond)
384: {
385: printf ("\tbreak only if ");
386: print_expression (b->cond, stdout);
387: printf ("\n");
388: }
389: if (l = b->commands)
390: while (l)
391: {
392: printf ("\t%s\n", l->line);
393: l = l->next;
394: }
395: }
396:
397: if (last_addr != -1)
398: set_next_address (last_addr);
399: }
400:
401: static void
402: breakpoints_info (bnum_exp)
403: char *bnum_exp;
404: {
405: int bnum = -1;
406:
407: if (bnum_exp)
408: bnum = parse_and_eval_address (bnum_exp);
409: else if (breakpoint_chain == 0)
410: printf ("No breakpoints.\n");
411: else
412: printf ("Breakpoints:\n\
413: Num Enb Address Where\n");
414:
415: breakpoint_1 (bnum);
416: }
417:
418: void
419: set_default_breakpoint (valid, addr, symtab, line)
420: int valid;
421: CORE_ADDR addr;
422: struct symtab *symtab;
423: int line;
424: {
425: default_breakpoint_valid = valid;
426: default_breakpoint_address = addr;
427: default_breakpoint_symtab = symtab;
428: default_breakpoint_line = line;
429: }
430:
431: /* Rescan breakpoints at address ADDRESS,
432: marking the first one as "first" and any others as "duplicates".
433: This is so that the bpt instruction is only inserted once. */
434:
435: static void
436: check_duplicates (address)
437: CORE_ADDR address;
438: {
439: register struct breakpoint *b;
440: register int count = 0;
441:
442: ALL_BREAKPOINTS (b)
443: if (b->enable != disabled && b->address == address)
444: {
445: count++;
446: b->duplicate = count > 1;
447: }
448: }
449:
450: /* Low level routine to set a breakpoint.
451: Takes as args the three things that every breakpoint must have.
452: Returns the breakpoint object so caller can set other things.
453: Does not set the breakpoint number!
454: Does not print anything. */
455:
456: static struct breakpoint *
457: set_raw_breakpoint (sal)
458: struct symtab_and_line sal;
459: {
460: register struct breakpoint *b, *b1;
461:
462: b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
463: bzero (b, sizeof *b);
464: b->address = sal.pc;
465: b->symtab = sal.symtab;
466: b->line_number = sal.line;
467: b->enable = enabled;
468: b->next = 0;
469:
470: /* Add this breakpoint to the end of the chain
471: so that a list of breakpoints will come out in order
472: of increasing numbers. */
473:
474: b1 = breakpoint_chain;
475: if (b1 == 0)
476: breakpoint_chain = b;
477: else
478: {
479: while (b1->next)
480: b1 = b1->next;
481: b1->next = b;
482: }
483:
484: check_duplicates (sal.pc);
485:
486: return b;
487: }
488:
489: /* Set a breakpoint that will evaporate an end of command
490: at address specified by SAL.
491: Restrict it to frame FRAME if FRAME is nonzero. */
492:
493: void
494: set_momentary_breakpoint (sal, frame)
495: struct symtab_and_line sal;
496: FRAME frame;
497: {
498: register struct breakpoint *b;
499: b = set_raw_breakpoint (sal);
500: b->number = -3;
501: b->enable = delete;
502: b->frame = frame;
503: }
504:
505: void
506: clear_momentary_breakpoints ()
507: {
508: register struct breakpoint *b;
509: ALL_BREAKPOINTS (b)
510: if (b->number == -3)
511: {
512: delete_breakpoint (b);
513: break;
514: }
515: }
516:
517: /* Set a breakpoint according to ARG (function, linenum or *address)
518: and make it temporary if TEMPFLAG is nonzero. */
519:
520: static void
521: break_command_1 (arg, tempflag, from_tty)
522: char *arg;
523: int tempflag, from_tty;
524: {
525: struct symtab_and_line sal;
526: register struct expression *cond = 0;
527: register struct breakpoint *b;
528:
529: sal.pc = 0;
530:
531: if (arg)
532: {
533: sal = decode_line_1 (&arg, 1, 0, 0);
534:
535: if (sal.pc == 0 && sal.symtab != 0)
536: {
537: sal.pc = find_line_pc (sal.symtab, sal.line);
538: if (sal.pc == 0)
539: error ("No line %d in file \"%s\".",
540: sal.line, sal.symtab->filename);
541: }
542:
543: while (*arg)
544: {
545: if (arg[0] == 'i' && arg[1] == 'f'
546: && (arg[2] == ' ' || arg[2] == '\t'))
547: cond = (struct expression *) parse_c_1 ((arg += 2, &arg),
548: block_for_pc (sal.pc));
549: else
550: error ("Junk at end of arguments.");
551: }
552: }
553: else if (default_breakpoint_valid)
554: {
555: sal.pc = default_breakpoint_address;
556: sal.line = default_breakpoint_line;
557: sal.symtab = default_breakpoint_symtab;
558: }
559: else
560: error ("No default breakpoint address now.");
561:
562: b = set_raw_breakpoint (sal);
563: b->number = ++breakpoint_count;
564: b->cond = cond;
565: if (tempflag)
566: b->enable = temporary;
567:
568: printf ("Breakpoint %d at 0x%x", b->number, b->address);
569: if (b->symtab)
570: printf (": file %s, line %d.", b->symtab->filename, b->line_number);
571: printf ("\n");
572:
573: if (from_tty)
574: {
575: int others = 0;
576: ALL_BREAKPOINTS (b)
577: if (b->address == sal.pc && b->number != breakpoint_count)
578: others++;
579: if (others > 0)
580: {
581: printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
582: ALL_BREAKPOINTS (b)
583: if (b->address == sal.pc && b->number != breakpoint_count)
584: {
585: others--;
586: printf ("%d%s%s ",
587: b->number,
588: (b->enable == disabled) ? " (disabled)" : "",
589: (others > 1) ? "," : ((others == 1) ? " and" : ""));
590: }
591: printf (" also set at pc 0x%x\n", sal.pc);
592: }
593: }
594: }
595:
596: static void
597: break_command (arg, from_tty)
598: char *arg;
599: int from_tty;
600: {
601: break_command_1 (arg, 0, from_tty);
602: }
603:
604: static void
605: tbreak_command (arg, from_tty)
606: char *arg;
607: int from_tty;
608: {
609: break_command_1 (arg, 1, from_tty);
610: }
611:
612: static void
613: clear_command (arg, from_tty)
614: char *arg;
615: int from_tty;
616: {
617: register struct breakpoint *b, *b1;
618: struct symtab_and_line sal;
619: register struct breakpoint *found;
620:
621: if (arg)
622: sal = decode_line_spec (arg, 1);
623: else
624: {
625: sal.line = default_breakpoint_line;
626: sal.symtab = default_breakpoint_symtab;
627: sal.pc = 0;
628: if (sal.symtab == 0)
629: error ("No source file specified.");
630: }
631:
632: /* If exact pc given, clear bpts at that pc.
633: But if sal.pc is zero, clear all bpts on specified line. */
634:
635: found = (struct breakpoint *) 0;
636: while (breakpoint_chain
637: && (sal.pc ? breakpoint_chain->address == sal.pc
638: : (breakpoint_chain->symtab == sal.symtab
639: && breakpoint_chain->line_number == sal.line)))
640: {
641: b1 = breakpoint_chain;
642: breakpoint_chain = b1->next;
643: b1->next = found;
644: found = b1;
645: }
646:
647: ALL_BREAKPOINTS (b)
648: while (b->next
649: && (sal.pc ? b->next->address == sal.pc
650: : (b->next->symtab == sal.symtab
651: && b->next->line_number == sal.line)))
652: {
653: b1 = b->next;
654: b->next = b1->next;
655: b1->next = found;
656: found = b1;
657: }
658:
659: if (found == 0)
660: error ("No breakpoint at %s.", arg);
661:
662: if (found->next) from_tty = 1; /* Alwats report if deleted more than one */
663: if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
664: while (found)
665: {
666: if (from_tty) printf ("%d ", found->number);
667: b1 = found->next;
668: delete_breakpoint (found);
669: found = b1;
670: }
671: if (from_tty) putchar ('\n');
672: }
673:
674: /* Delete breakpoint number BNUM if it is a `delete' breakpoint.
675: This is called after breakpoint BNUM has been hit.
676: Also delete any breakpoint numbered -3 unless there are breakpoint
677: commands to be executed. */
678:
679: void
680: breakpoint_auto_delete (bnum)
681: int bnum;
682: {
683: register struct breakpoint *b;
684: if (bnum != 0)
685: ALL_BREAKPOINTS (b)
686: if (b->number == bnum)
687: {
688: if (b->enable == delete)
689: delete_breakpoint (b);
690: break;
691: }
692: if (breakpoint_commands == 0)
693: clear_momentary_breakpoints ();
694: }
695:
696: static void
697: delete_breakpoint (bpt)
698: struct breakpoint *bpt;
699: {
700: register struct breakpoint *b;
701:
702: if (bpt->inserted)
703: write_memory (bpt->address, bpt->shadow_contents, sizeof break_insn);
704:
705: if (breakpoint_chain == bpt)
706: breakpoint_chain = bpt->next;
707:
708: ALL_BREAKPOINTS (b)
709: if (b->next == bpt)
710: {
711: b->next = bpt->next;
712: break;
713: }
714:
715: check_duplicates (bpt->address);
716:
717: free_command_lines (&bpt->commands);
718: if (bpt->cond)
719: free (bpt->cond);
720: free (bpt);
721: }
722:
723: void map_breakpoint_numbers ();
724:
725: static void
726: delete_command (arg, from_tty)
727: char *arg;
728: int from_tty;
729: {
730: register struct breakpoint *b, *b1;
731:
732: if (arg == 0)
733: {
734: if (!from_tty || query ("Delete all breakpoints? "))
735: {
736: /* No arg; clear all breakpoints. */
737: while (breakpoint_chain)
738: delete_breakpoint (breakpoint_chain);
739: }
740: }
741: else
742: map_breakpoint_numbers (arg, delete_breakpoint);
743: }
744:
745: /* Delete all breakpoints.
746: Done when new symtabs are loaded, since the break condition expressions
747: may become invalid, and the breakpoints are probably wrong anyway. */
748:
749: void
750: clear_breakpoints ()
751: {
752: delete_command (0, 0);
753: }
754:
755: /* Set ignore-count of breakpoint number BPTNUM to COUNT.
756: If from_tty is nonzero, it prints a message to that effect,
757: which ends with a period (no newline). */
758:
759: void
760: set_ignore_count (bptnum, count, from_tty)
761: int bptnum, count, from_tty;
762: {
763: register struct breakpoint *b;
764:
765: if (count < 0)
766: count = 0;
767:
768: ALL_BREAKPOINTS (b)
769: if (b->number == bptnum)
770: {
771: b->ignore_count = count;
772: if (!from_tty)
773: return;
774: else if (count == 0)
775: printf ("Will stop next time breakpoint %d is reached.", bptnum);
776: else if (count == 1)
777: printf ("Will ignore next crossing of breakpoint %d.", bptnum);
778: else
779: printf ("Will ignore next %d crossings of breakpoint %d.",
780: count, bptnum);
781: return;
782: }
783:
784: error ("No breakpoint number %d.", bptnum);
785: }
786:
787: /* Command to set ignore-count of breakpoint N to COUNT. */
788:
789: static void
790: ignore_command (args, from_tty)
791: char *args;
792: int from_tty;
793: {
794: register char *p;
795: register int num;
796:
797: p = args;
798: while (*p >= '0' && *p <= '9') p++;
799: if (*p && *p != ' ' && *p != '\t')
800: error ("First argument must be a breakpoint number.");
801:
802: num = atoi (args);
803:
804: if (*p == 0)
805: error ("Second argument (specified ignore-count) is missing.");
806:
807: set_ignore_count (num, parse_and_eval_address (p), from_tty);
808: printf ("\n");
809: }
810:
811: /* Call FUNCTION on each of the breakpoints
812: whose numbers are given in ARGS. */
813:
814: static void
815: map_breakpoint_numbers (args, function)
816: char *args;
817: void (*function) ();
818: {
819: register char *p = args;
820: register char *p1;
821: register int num;
822: register struct breakpoint *b;
823:
824: if (p == 0)
825: error_no_arg ("one or more breakpoint numbers");
826:
827: while (*p)
828: {
829: p1 = p;
830: while (*p1 >= '0' && *p1 <= '9') p1++;
831: if (*p1 && *p1 != ' ' && *p1 != '\t')
832: error ("Arguments must be breakpoint numbers.");
833:
834: num = atoi (p);
835:
836: ALL_BREAKPOINTS (b)
837: if (b->number == num)
838: {
839: function (b);
840: goto win;
841: }
842: printf ("No breakpoint number %d.\n", num);
843: win:
844: p = p1;
845: while (*p == ' ' || *p == '\t') p++;
846: }
847: }
848:
849: static void
850: enable_breakpoint (bpt)
851: struct breakpoint *bpt;
852: {
853: bpt->enable = enabled;
854:
855: check_duplicates (bpt->address);
856: }
857:
858: static void
859: enable_command (args)
860: char *args;
861: {
862: map_breakpoint_numbers (args, enable_breakpoint);
863: }
864:
865: static void
866: disable_breakpoint (bpt)
867: struct breakpoint *bpt;
868: {
869: bpt->enable = disabled;
870:
871: check_duplicates (bpt->address);
872: }
873:
874: static void
875: disable_command (args)
876: char *args;
877: {
878: register struct breakpoint *bpt;
879: if (args == 0)
880: ALL_BREAKPOINTS (bpt)
881: disable_breakpoint (bpt);
882: else
883: map_breakpoint_numbers (args, disable_breakpoint);
884: }
885:
886: static void
887: enable_once_breakpoint (bpt)
888: struct breakpoint *bpt;
889: {
890: bpt->enable = temporary;
891:
892: check_duplicates (bpt->address);
893: }
894:
895: static void
896: enable_once_command (args)
897: char *args;
898: {
899: map_breakpoint_numbers (args, enable_once_breakpoint);
900: }
901:
902: static void
903: enable_delete_breakpoint (bpt)
904: struct breakpoint *bpt;
905: {
906: bpt->enable = delete;
907:
908: check_duplicates (bpt->address);
909: }
910:
911: static void
912: enable_delete_command (args)
913: char *args;
914: {
915: map_breakpoint_numbers (args, enable_delete_breakpoint);
916: }
917:
918:
919: /* Chain containing all defined enable commands. */
920:
921: struct cmd_list_element *enablelist;
922:
923: extern struct cmd_list_element *cmdlist;
924:
925: static
926: initialize ()
927: {
928: breakpoint_chain = 0;
929: breakpoint_count = 0;
930: enablelist = 0;
931:
932: add_com ("ignore", class_breakpoint, ignore_command,
933: "Set ignore-count of breakpoint number N to COUNT.");
934:
935: add_com ("commands", class_breakpoint, commands_command,
936: "Set commands to be executed when a breakpoint is hit.\n\
937: Give breakpoint number as argument after \"commands\".\n\
938: The commands themselves follow starting on the next line.\n\
939: Type a line containing \"end\" to indicate the end of them.\n\
940: Give \"silent\" as the first line to make the breakpoint silent;\n\
941: then no output is printed when it is hit, except what the commands print.");
942:
943: add_com ("condition", class_breakpoint, condition_command,
944: "Specify breakpoint number N to break only if COND is true.\n\
945: N is an integer; COND is a C expression to be evaluated whenever\n\
946: breakpoint N is reached. Actually break only when COND is nonzero.");
947:
948: add_com ("tbreak", class_breakpoint, tbreak_command,
949: "Set a temporary breakpoint. Args like \"break\" command.\n\
950: Like \"break\" except the breakpoint is only enabled temporarily,\n\
951: so it will be disabled when hit. Equivalent to \"break\" followed\n\
952: by using \"enable once\" on the breakpoint number.");
953:
954: add_prefix_cmd ("enable", class_breakpoint, enable_command,
955: "Enable some breakpoints. Give breakpoint numbers as arguments.\n\
956: With no subcommand, breakpoints are enabled until you command otherwise.\n\
957: This is used to cancel the effect of the \"disable\" command.\n\
958: With a subcommand you can enable temporarily.",
959: &enablelist, "enable ", 1, &cmdlist);
960:
961: add_cmd ("delete", 0, enable_delete_command,
962: "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
963: If a breakpoint is hit while enabled in this fashion, it is deleted.",
964: &enablelist);
965:
966: add_cmd ("once", 0, enable_once_command,
967: "Enable breakpoints for one hit. Give breakpoint numbers.\n\
968: If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
969: See the \"tbreak\" command which sets a breakpoint and enables it once.",
970: &enablelist);
971:
972: add_com ("disable", class_breakpoint, disable_command,
973: "Disable some breakpoints. Give breakpoint numbers as arguments.\n\
974: With no arguments, disable all breakpoints.\n\
975: A disabled breakpoint is not forgotten,\n\
976: but it has no effect until enabled again.");
977: add_com_alias ("dis", "disable", class_breakpoint, 1);
978:
979: add_com ("delete", class_breakpoint, delete_command,
980: "Delete breakpoints, specifying breakpoint numbers; or all breakpoints.\n\
981: Arguments are breakpoint numbers with spaces in between.\n\
982: To delete all breakpoints, give no argument.");
983: add_com_alias ("d", "delete", class_breakpoint, 1);
984:
985: add_com ("clear", class_breakpoint, clear_command,
986: "Clear breakpoint at specified line or function.\n\
987: Argument may be line number, function name, or \"*\" and an address.\n\
988: If line number is specified, all breakpoints in that line are cleared.\n\
989: If function is specified, breakpoints at beginning of function are cleared.\n\
990: If an address is specified, breakpoints at that address are cleared.\n\n\
991: With no argument, clears all breakpoints in the line that the selected frame\n\
992: is executing in.\n\
993: \n\
994: See also the \"delete\" command which clears breakpoints by number.");
995:
996: add_com ("break", class_breakpoint, break_command,
997: "Set breakpoint at specified line or function.\n\
998: Argument may be line number, function name, or \"*\" and an address.\n\
999: If line number is specified, break at start of code for that line.\n\
1000: If function is specified, break at start of code for that function.\n\
1001: If an address is specified, break at that exact address.\n\
1002: With no arg, uses current execution address of selected stack frame.\n\
1003: This is useful for breaking on return to a stack frame.\n\
1004: \n\
1005: Multiple breakpoints at one place are permitted, and useful if conditional.\n\
1006: \n\
1007: Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
1008: add_com_alias ("b", "break", class_run, 1);
1009: add_com_alias ("br", "break", class_run, 1);
1010: add_com_alias ("bre", "break", class_run, 1);
1011: add_com_alias ("brea", "break", class_run, 1);
1012:
1013: add_info ("breakpoints", breakpoints_info,
1014: "Status of all breakpoints, or breakpoint number NUMBER.\n\
1015: Second column is \"y\" for enabled breakpoint, \"d\" for disabled,\n\
1016: \"o\" for enabled once (disable when hit), \"d\" for enable but delete when hit.\n\
1017: Then come the address and the file/line number.\n\n\
1018: Convenience variable \"$_\" and default examine address for \"x\"\n\
1019: are set to the address of the last breakpoint listed.");
1020: }
1021:
1022: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.