![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to events.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / dbx|
Return to events.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)events.c 5.1 (Berkeley) 5/31/85";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: events.c,v 1.5 84/12/26 10:39:26 linton Exp $";
12:
13: /*
14: * Event/breakpoint managment.
15: */
16:
17: #include "defs.h"
18: #include "events.h"
19: #include "main.h"
20: #include "symbols.h"
21: #include "tree.h"
22: #include "eval.h"
23: #include "source.h"
24: #include "mappings.h"
25: #include "runtime.h"
26: #include "process.h"
27: #include "machine.h"
28: #include "lists.h"
29:
30: #ifndef public
31: typedef struct Event *Event;
32: typedef struct Breakpoint *Breakpoint;
33:
34: boolean inst_tracing;
35: boolean single_stepping;
36: boolean isstopped;
37:
38: #include "symbols.h"
39:
40: Symbol linesym;
41: Symbol procsym;
42: Symbol pcsym;
43: Symbol retaddrsym;
44:
45: #define addevent(cond, cmdlist) event_alloc(false, cond, cmdlist)
46: #define event_once(cond, cmdlist) event_alloc(true, cond, cmdlist)
47:
48: #endif
49:
50: struct Event {
51: unsigned int id;
52: boolean temporary;
53: Node condition;
54: Cmdlist actions;
55: };
56:
57: struct Breakpoint {
58: Event event;
59: Address bpaddr;
60: Lineno bpline;
61: Cmdlist actions;
62: boolean temporary;
63: };
64:
65: typedef List Eventlist;
66: typedef List Bplist;
67:
68: #define eventlist_append(event, el) list_append(list_item(event), nil, el)
69: #define bplist_append(bp, bl) list_append(list_item(bp), nil, bl)
70:
71: private Eventlist eventlist; /* list of active events */
72: private Bplist bplist; /* list of active breakpoints */
73: private Event curevent; /* most recently created event */
74: private integer eventid; /* id number of current event */
75: private integer trid; /* id number of current trace */
76:
77: typedef struct Trcmd {
78: Integer trid;
79: Event event;
80: Cmdlist cmdlist;
81: } *Trcmd;
82:
83: private List eachline; /* commands to execute after each line */
84: private List eachinst; /* commands to execute after each instruction */
85:
86: private Breakpoint bp_alloc();
87:
88: /*
89: * Initialize breakpoint information.
90: */
91:
92: private Symbol builtinsym(str, class, type)
93: String str;
94: Symclass class;
95: Symbol type;
96: {
97: Symbol s;
98:
99: s = insert(identname(str, true));
100: s->language = findlanguage(".s");
101: s->class = class;
102: s->type = type;
103: return s;
104: }
105:
106: public bpinit()
107: {
108: linesym = builtinsym("$line", VAR, t_int);
109: procsym = builtinsym("$proc", PROC, nil);
110: pcsym = lookup(identname("$pc", true));
111: if (pcsym == nil) {
112: panic("can't find $pc");
113: }
114: retaddrsym = builtinsym("$retaddr", VAR, t_int);
115: eventlist = list_alloc();
116: bplist = list_alloc();
117: eachline = list_alloc();
118: eachinst = list_alloc();
119: }
120:
121: /*
122: * Trap an event and do the associated commands when it occurs.
123: */
124:
125: public Event event_alloc(istmp, econd, cmdlist)
126: boolean istmp;
127: Node econd;
128: Cmdlist cmdlist;
129: {
130: register Event e;
131:
132: e = new(Event);
133: ++eventid;
134: e->id = eventid;
135: e->temporary = istmp;
136: e->condition = econd;
137: e->actions = cmdlist;
138: eventlist_append(e, eventlist);
139: curevent = e;
140: translate(e);
141: return e;
142: }
143:
144: /*
145: * Delete the event with the given id.
146: * Returns whether it's successful or not.
147: */
148:
149: public boolean delevent (id)
150: unsigned int id;
151: {
152: Event e;
153: Breakpoint bp;
154: Trcmd t;
155: boolean found;
156:
157: found = false;
158: foreach (Event, e, eventlist)
159: if (e->id == id) {
160: found = true;
161: foreach (Breakpoint, bp, bplist)
162: if (bp->event == e) {
163: if (tracebpts) {
164: printf("deleting breakpoint at 0x%x\n", bp->bpaddr);
165: fflush(stdout);
166: }
167: list_delete(list_curitem(bplist), bplist);
168: }
169: endfor
170: list_delete(list_curitem(eventlist), eventlist);
171: break;
172: }
173: endfor
174: foreach (Trcmd, t, eachline)
175: if (t->event->id == id) {
176: found = true;
177: printrmtr(t);
178: list_delete(list_curitem(eachline), eachline);
179: }
180: endfor
181: foreach (Trcmd, t, eachinst)
182: if (t->event->id == id) {
183: found = true;
184: printrmtr(t);
185: list_delete(list_curitem(eachinst), eachinst);
186: }
187: endfor
188: if (list_size(eachinst) == 0) {
189: inst_tracing = false;
190: if (list_size(eachline) == 0) {
191: single_stepping = false;
192: }
193: }
194: return found;
195: }
196:
197: /*
198: * Translate an event into the appropriate breakpoints and actions.
199: * While we're at it, turn on the breakpoints if the condition is true.
200: */
201:
202: private translate(e)
203: Event e;
204: {
205: Breakpoint bp;
206: Symbol s;
207: Node place;
208: Lineno line;
209: Address addr;
210:
211: checkref(e->condition);
212: switch (e->condition->op) {
213: case O_EQ:
214: if (e->condition->value.arg[0]->op == O_SYM) {
215: s = e->condition->value.arg[0]->value.sym;
216: place = e->condition->value.arg[1];
217: if (s == linesym) {
218: if (place->op == O_QLINE) {
219: line = place->value.arg[1]->value.lcon;
220: addr = objaddr(line, place->value.arg[0]->value.scon);
221: } else {
222: eval(place);
223: line = pop(long);
224: addr = objaddr(line, cursource);
225: }
226: if (addr == NOADDR) {
227: if (not delevent(e->id)) {
228: printf("!! dbx.translate: can't undo event %d?\n",
229: e->id);
230: }
231: beginerrmsg();
232: fprintf(stderr, "no executable code at line ");
233: prtree(stderr, place);
234: enderrmsg();
235: }
236: bp = bp_alloc(e, addr, line, e->actions);
237: } else if (s == procsym) {
238: eval(place);
239: s = pop(Symbol);
240: bp = bp_alloc(e, codeloc(s), 0, e->actions);
241: if (isactive(s) and pc != codeloc(program)) {
242: evalcmdlist(e->actions);
243: }
244: } else if (s == pcsym) {
245: eval(place);
246: bp = bp_alloc(e, pop(Address), 0, e->actions);
247: } else {
248: condbp(e);
249: }
250: } else {
251: condbp(e);
252: }
253: break;
254:
255: /*
256: * These should be handled specially.
257: * But for now I'm ignoring the problem.
258: */
259: case O_AND:
260: case O_OR:
261: default:
262: condbp(e);
263: break;
264: }
265: }
266:
267: /*
268: * Create a breakpoint for a condition that cannot be pinpointed
269: * to happening at a particular address, but one for which we
270: * must single step and check the condition after each statement.
271: */
272:
273: private condbp(e)
274: Event e;
275: {
276: Symbol p;
277: Breakpoint bp;
278: Cmdlist actions;
279:
280: p = tcontainer(e->condition);
281: if (p == nil) {
282: p = program;
283: }
284: actions = buildcmdlist(build(O_IF, e->condition, e->actions));
285: actions = buildcmdlist(build(O_TRACEON, false, actions));
286: bp = bp_alloc(e, codeloc(p), 0, actions);
287: }
288:
289: /*
290: * Determine the deepest nested subprogram that still contains
291: * all elements in the given expression.
292: */
293:
294: public Symbol tcontainer(exp)
295: Node exp;
296: {
297: Integer i;
298: Symbol s, t, u, v;
299:
300: checkref(exp);
301: s = nil;
302: if (exp->op == O_SYM) {
303: s = container(exp->value.sym);
304: } else if (not isleaf(exp->op)) {
305: for (i = 0; i < nargs(exp->op); i++) {
306: t = tcontainer(exp->value.arg[i]);
307: if (t != nil) {
308: if (s == nil) {
309: s = t;
310: } else {
311: u = s;
312: v = t;
313: while (u != v and u != nil) {
314: u = container(u);
315: v = container(v);
316: }
317: if (u == nil) {
318: panic("bad ancestry for \"%s\"", symname(s));
319: } else {
320: s = u;
321: }
322: }
323: }
324: }
325: }
326: return s;
327: }
328:
329: /*
330: * Determine if the given function can be executed at full speed.
331: * This can only be done if there are no breakpoints within the function.
332: */
333:
334: public boolean canskip(f)
335: Symbol f;
336: {
337: Breakpoint p;
338: boolean ok;
339:
340: ok = true;
341: foreach (Breakpoint, p, bplist)
342: if (whatblock(p->bpaddr) == f) {
343: ok = false;
344: break;
345: }
346: endfor
347: return ok;
348: }
349:
350: /*
351: * Print out what's currently being traced by looking at
352: * the currently active events.
353: *
354: * Some convolution here to translate internal representation
355: * of events back into something more palatable.
356: */
357:
358: public status()
359: {
360: Event e;
361:
362: foreach (Event, e, eventlist)
363: if (not e->temporary) {
364: printevent(e);
365: }
366: endfor
367: }
368:
369: public printevent(e)
370: Event e;
371: {
372: Command cmd;
373:
374: if (not isredirected()) {
375: printeventid(e->id);
376: }
377: cmd = list_element(Command, list_head(e->actions));
378: if (cmd->op == O_PRINTCALL) {
379: printf("trace ");
380: printname(stdout, cmd->value.sym);
381: } else {
382: if (list_size(e->actions) > 1) {
383: printf("{ ");
384: }
385: foreach (Command, cmd, e->actions)
386: printcmd(stdout, cmd);
387: if (not list_islast()) {
388: printf("; ");
389: }
390: endfor
391: if (list_size(e->actions) > 1) {
392: printf(" }");
393: }
394: printcond(e->condition);
395: }
396: printf("\n");
397: }
398:
399: private printeventid (id)
400: integer id;
401: {
402: printf("[%d] ", id);
403: }
404:
405: /*
406: * Print out a condition.
407: */
408:
409: private printcond(cond)
410: Node cond;
411: {
412: Symbol s;
413: Node place;
414:
415: if (cond->op == O_EQ and cond->value.arg[0]->op == O_SYM) {
416: s = cond->value.arg[0]->value.sym;
417: place = cond->value.arg[1];
418: if (s == procsym) {
419: if (place->value.sym != program) {
420: printf(" in ");
421: printname(stdout, place->value.sym);
422: }
423: } else if (s == linesym) {
424: printf(" at ");
425: prtree(stdout, place);
426: } else if (s == pcsym or s == retaddrsym) {
427: printf("i at ");
428: prtree(stdout, place);
429: } else {
430: printf(" when ");
431: prtree(stdout, cond);
432: }
433: } else {
434: printf(" when ");
435: prtree(stdout, cond);
436: }
437: }
438:
439: /*
440: * Add a breakpoint to the list and return it.
441: */
442:
443: private Breakpoint bp_alloc(e, addr, line, actions)
444: Event e;
445: Address addr;
446: Lineno line;
447: Cmdlist actions;
448: {
449: register Breakpoint p;
450:
451: p = new(Breakpoint);
452: p->event = e;
453: p->bpaddr = addr;
454: p->bpline = line;
455: p->actions = actions;
456: p->temporary = false;
457: if (tracebpts) {
458: if (e == nil) {
459: printf("new bp at 0x%x for event ??\n", addr, e->id);
460: } else {
461: printf("new bp at 0x%x for event %d\n", addr, e->id);
462: }
463: fflush(stdout);
464: }
465: bplist_append(p, bplist);
466: return p;
467: }
468:
469: /*
470: * Free all storage in the event and breakpoint tables.
471: */
472:
473: public bpfree()
474: {
475: register Event e;
476:
477: fixbps();
478: foreach (Event, e, eventlist)
479: if (not delevent(e->id)) {
480: printf("!! dbx.bpfree: can't delete event %d\n", e->id);
481: }
482: list_delete(list_curitem(eventlist), eventlist);
483: endfor
484: }
485:
486: /*
487: * Determine if the program stopped at a known breakpoint
488: * and if so do the associated commands.
489: */
490:
491: public boolean bpact()
492: {
493: register Breakpoint p;
494: boolean found;
495: integer eventId;
496:
497: found = false;
498: foreach (Breakpoint, p, bplist)
499: if (p->bpaddr == pc) {
500: if (tracebpts) {
501: printf("breakpoint for event %d found at location 0x%x\n",
502: p->event->id, pc);
503: }
504: found = true;
505: if (p->event->temporary) {
506: if (not delevent(p->event->id)) {
507: printf("!! dbx.bpact: can't find event %d\n",
508: p->event->id);
509: }
510: }
511: evalcmdlist(p->actions);
512: if (isstopped) {
513: eventId = p->event->id;
514: }
515: if (p->temporary) {
516: list_delete(list_curitem(bplist), bplist);
517: }
518: }
519: endfor
520: if (isstopped) {
521: if (found) {
522: printeventid(eventId);
523: }
524: printstatus();
525: }
526: fflush(stdout);
527: return found;
528: }
529:
530: /*
531: * Begin single stepping and executing the given commands after each step.
532: * If the first argument is true step by instructions, otherwise
533: * step by source lines.
534: *
535: * We automatically set a breakpoint at the end of the current procedure
536: * to turn off the given tracing.
537: */
538:
539: public traceon(inst, event, cmdlist)
540: boolean inst;
541: Event event;
542: Cmdlist cmdlist;
543: {
544: register Trcmd trcmd;
545: Breakpoint bp;
546: Cmdlist actions;
547: Address ret;
548: Event e;
549:
550: if (event == nil) {
551: e = curevent;
552: } else {
553: e = event;
554: }
555: trcmd = new(Trcmd);
556: ++trid;
557: trcmd->trid = trid;
558: trcmd->event = e;
559: trcmd->cmdlist = cmdlist;
560: single_stepping = true;
561: if (inst) {
562: inst_tracing = true;
563: list_append(list_item(trcmd), nil, eachinst);
564: } else {
565: list_append(list_item(trcmd), nil, eachline);
566: }
567: ret = return_addr();
568: if (ret != 0) {
569: actions = buildcmdlist(build(O_TRACEOFF, trcmd->trid));
570: bp = bp_alloc(e, (Address) ret, 0, actions);
571: bp->temporary = true;
572: }
573: if (tracebpts) {
574: printf("adding trace %d for event %d\n", trcmd->trid, e->id);
575: }
576: }
577:
578: /*
579: * Turn off some kind of tracing.
580: * Strictly an internal command, this cannot be invoked by the user.
581: */
582:
583: public traceoff(id)
584: Integer id;
585: {
586: register Trcmd t;
587: register boolean found;
588:
589: found = false;
590: foreach (Trcmd, t, eachline)
591: if (t->trid == id) {
592: printrmtr(t);
593: list_delete(list_curitem(eachline), eachline);
594: found = true;
595: break;
596: }
597: endfor
598: if (not found) {
599: foreach (Trcmd, t, eachinst)
600: if (t->event->id == id) {
601: printrmtr(t);
602: list_delete(list_curitem(eachinst), eachinst);
603: found = true;
604: break;
605: }
606: endfor
607: if (not found) {
608: beginerrmsg();
609: fprintf(stderr, "[internal error: trace id %d not found]\n", id);
610: }
611: }
612: if (list_size(eachinst) == 0) {
613: inst_tracing = false;
614: if (list_size(eachline) == 0) {
615: single_stepping = false;
616: }
617: }
618: }
619:
620: /*
621: * If breakpoints are being traced, note that a Trcmd is being deleted.
622: */
623:
624: private printrmtr(t)
625: Trcmd t;
626: {
627: if (tracebpts) {
628: printf("removing trace %d", t->trid);
629: if (t->event != nil) {
630: printf(" for event %d", t->event->id);
631: }
632: printf("\n");
633: }
634: }
635:
636: /*
637: * Print out news during single step tracing.
638: */
639:
640: public printnews()
641: {
642: register Trcmd t;
643:
644: foreach (Trcmd, t, eachline)
645: evalcmdlist(t->cmdlist);
646: endfor
647: foreach (Trcmd, t, eachinst)
648: evalcmdlist(t->cmdlist);
649: endfor
650: bpact();
651: }
652:
653: /*
654: * A procedure call/return has occurred while single-stepping,
655: * note it if we're tracing lines.
656: */
657:
658: private boolean chklist();
659:
660: public callnews(iscall)
661: boolean iscall;
662: {
663: if (not chklist(eachline, iscall)) {
664: chklist(eachinst, iscall);
665: }
666: }
667:
668: private boolean chklist(list, iscall)
669: List list;
670: boolean iscall;
671: {
672: register Trcmd t;
673: register Command cmd;
674:
675: setcurfunc(whatblock(pc));
676: foreach (Trcmd, t, list)
677: foreach (Command, cmd, t->cmdlist)
678: if (cmd->op == O_PRINTSRCPOS and
679: (cmd->value.arg[0] == nil or cmd->value.arg[0]->op == O_QLINE)) {
680: if (iscall) {
681: printentry(curfunc);
682: } else {
683: printexit(curfunc);
684: }
685: return true;
686: }
687: endfor
688: endfor
689: return false;
690: }
691:
692: /*
693: * When tracing variables we keep a copy of their most recent value
694: * and compare it to the current one each time a breakpoint occurs.
695: * MAXTRSIZE is the maximum size variable we allow.
696: */
697:
698: #define MAXTRSIZE 512
699:
700: /*
701: * List of variables being watched.
702: */
703:
704: typedef struct Trinfo *Trinfo;
705:
706: struct Trinfo {
707: Node variable;
708: Address traddr;
709: Symbol trblock;
710: char *trvalue;
711: };
712:
713: private List trinfolist;
714:
715: /*
716: * Find the trace information record associated with the given record.
717: * If there isn't one then create it and add it to the list.
718: */
719:
720: private Trinfo findtrinfo(p)
721: Node p;
722: {
723: register Trinfo tp;
724: boolean isnew;
725:
726: isnew = true;
727: if (trinfolist == nil) {
728: trinfolist = list_alloc();
729: } else {
730: foreach (Trinfo, tp, trinfolist)
731: if (tp->variable == p) {
732: isnew = false;
733: break;
734: }
735: endfor
736: }
737: if (isnew) {
738: if (tracebpts) {
739: printf("adding trinfo for \"");
740: prtree(stdout, p);
741: printf("\"\n");
742: }
743: tp = new(Trinfo);
744: tp->variable = p;
745: tp->traddr = lval(p);
746: tp->trvalue = nil;
747: list_append(list_item(tp), nil, trinfolist);
748: }
749: return tp;
750: }
751:
752: /*
753: * Print out the value of a variable if it has changed since the
754: * last time we checked.
755: */
756:
757: public printifchanged(p)
758: Node p;
759: {
760: register Trinfo tp;
761: register int n;
762: char buff[MAXTRSIZE];
763: Filename curfile;
764: static Lineno prevline;
765: static Filename prevfile;
766:
767: tp = findtrinfo(p);
768: n = size(p->nodetype);
769: dread(buff, tp->traddr, n);
770: curfile = srcfilename(pc);
771: if (tp->trvalue == nil) {
772: tp->trvalue = newarr(char, n);
773: mov(buff, tp->trvalue, n);
774: mov(buff, sp, n);
775: sp += n;
776: printf("initially (at line %d in \"%s\"):\t", curline, curfile);
777: prtree(stdout, p);
778: printf(" = ");
779: printval(p->nodetype);
780: putchar('\n');
781: } else if (cmp(tp->trvalue, buff, n) != 0) {
782: mov(buff, tp->trvalue, n);
783: mov(buff, sp, n);
784: sp += n;
785: printf("after line %d in \"%s\":\t", prevline, prevfile);
786: prtree(stdout, p);
787: printf(" = ");
788: printval(p->nodetype);
789: putchar('\n');
790: }
791: prevline = curline;
792: prevfile = curfile;
793: }
794:
795: /*
796: * Stop if the value of the given expression has changed.
797: */
798:
799: public stopifchanged(p)
800: Node p;
801: {
802: register Trinfo tp;
803: register int n;
804: char buff[MAXTRSIZE];
805: static Lineno prevline;
806:
807: tp = findtrinfo(p);
808: n = size(p->nodetype);
809: dread(buff, tp->traddr, n);
810: if (tp->trvalue == nil) {
811: tp->trvalue = newarr(char, n);
812: mov(buff, tp->trvalue, n);
813: isstopped = true;
814: } else if (cmp(tp->trvalue, buff, n) != 0) {
815: mov(buff, tp->trvalue, n);
816: mov(buff, sp, n);
817: sp += n;
818: printf("after line %d:\t", prevline);
819: prtree(stdout, p);
820: printf(" = ");
821: printval(p->nodetype);
822: putchar('\n');
823: isstopped = true;
824: }
825: prevline = curline;
826: }
827:
828: /*
829: * Free the tracing table.
830: */
831:
832: public trfree()
833: {
834: register Trinfo tp;
835:
836: foreach (Trinfo, tp, trinfolist)
837: dispose(tp->trvalue);
838: dispose(tp);
839: list_delete(list_curitem(trinfolist), trinfolist);
840: endfor
841: }
842:
843: /*
844: * Fix up breakpoint information before continuing execution.
845: *
846: * It's necessary to destroy events and breakpoints that were created
847: * temporarily and still exist because the program terminated abnormally.
848: */
849:
850: public fixbps()
851: {
852: register Event e;
853: register Trcmd t;
854:
855: single_stepping = false;
856: inst_tracing = false;
857: trfree();
858: foreach (Event, e, eventlist)
859: if (e->temporary) {
860: if (not delevent(e->id)) {
861: printf("!! dbx.fixbps: can't find event %d\n", e->id);
862: }
863: }
864: endfor
865: foreach (Trcmd, t, eachline)
866: printrmtr(t);
867: list_delete(list_curitem(eachline), eachline);
868: endfor
869: foreach (Trcmd, t, eachinst)
870: printrmtr(t);
871: list_delete(list_curitem(eachinst), eachinst);
872: endfor
873: }
874:
875: /*
876: * Set all breakpoints in object code.
877: */
878:
879: public setallbps()
880: {
881: register Breakpoint p;
882:
883: foreach (Breakpoint, p, bplist)
884: setbp(p->bpaddr);
885: endfor
886: }
887:
888: /*
889: * Undo damage done by "setallbps".
890: */
891:
892: public unsetallbps()
893: {
894: register Breakpoint p;
895:
896: foreach (Breakpoint, p, bplist)
897: unsetbp(p->bpaddr);
898: endfor
899: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.