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