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