![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tracestop.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx / tree|
Return to tracestop.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx / tree |
1.1 root 1: /* Copyright (c) 1982 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)tracestop.c 1.1 1/18/82";
4:
5: /*
6: * Handle trace and stop commands.
7: */
8:
9: #include "defs.h"
10: #include "breakpoint.h"
11: #include "sym.h"
12: #include "tree.h"
13: #include "runtime.h"
14: #include "source.h"
15: #include "object.h"
16: #include "mappings.h"
17: #include "machine.h"
18: #include "tree.rep"
19:
20: LOCAL SYM *tcontainer();
21:
22: /*
23: * Process a trace/untrace command, basically checking arguments
24: * and translate to a call of the appropriate routine.
25: */
26:
27: trace(cmd, exp, where, cond)
28: int cmd;
29: NODE *exp;
30: NODE *where;
31: NODE *cond;
32: {
33: if (exp == NIL) {
34: traceall(cmd, where, cond);
35: } else if (exp->op == O_LCON || exp->op == O_QLINE) {
36: traceinst(cmd, exp, where, cond);
37: } else if (where!=NIL && (where->op==O_QLINE || where->op==O_LCON)) {
38: traceat(cmd, exp, where, cond);
39: } else {
40: tracedata(cmd, exp, where, cond);
41: }
42: if (where != NIL) {
43: tfree(where);
44: }
45: }
46:
47: /*
48: * Set a breakpoint that will turn on tracing.
49: *
50: * A line number of 0 in the breakpoint information structure
51: * means it's a normal trace.
52: *
53: * A line number of -1 indicates that we want to trace at the instruction
54: * rather than source line level.
55: *
56: * If location is NIL, turn on tracing because if the user
57: * has the program stopped somewhere and says "trace",
58: * he/she wants to see tracing after continuing execution.
59: */
60:
61: LOCAL traceall(cmd, where, cond)
62: int cmd;
63: NODE *where;
64: NODE *cond;
65: {
66: SYM *s;
67: LINENO line;
68:
69: if (where != NIL && where->op != O_NAME) {
70: error("bad location for trace");
71: }
72: if (cmd == O_TRACE) {
73: line = 0;
74: } else {
75: line = -1;
76: }
77: if (where == NIL) {
78: switch (cmd) {
79: case O_TRACE:
80: if (tracing != 0) {
81: error("already tracing lines");
82: }
83: tracing++;
84: addcond(TRPRINT, cond);
85: break;
86:
87: case O_TRACEI:
88: if (inst_tracing != 0) {
89: error("already tracing instructions");
90: }
91: inst_tracing++;
92: addcond(TRPRINT, cond);
93: break;
94:
95: default:
96: panic("bad cmd in traceall");
97: break;
98: }
99: s = program;
100: } else if (where->op != O_NAME) {
101: trerror("found %t, expected procedure or function", where);
102: } else {
103: s = where->nameval;
104: if (!isblock(s)) {
105: error("\"%s\" is not a procedure or function", name(s));
106: }
107: }
108: addbp(codeloc(s), ALL_ON, s, cond, NIL, line);
109: }
110:
111: /*
112: * Set up the appropriate breakpoint for tracing an instruction.
113: */
114:
115: LOCAL traceinst(cmd, exp, where, cond)
116: int cmd;
117: NODE *exp;
118: NODE *where;
119: NODE *cond;
120: {
121: LINENO line;
122: ADDRESS addr;
123:
124: if (where != NIL) {
125: error("unexpected \"at\" or \"in\"");
126: }
127: if (cmd == O_TRACEI) {
128: if (exp->op == O_QLINE) {
129: addr = (ADDRESS) exp->right->lconval;
130: } else if (exp->op == O_LCON) {
131: addr = (ADDRESS) exp->lconval;
132: } else {
133: trerror("expected integer constant, found %t", exp);
134: }
135: line = -1;
136: } else {
137: if (exp->op == O_QLINE) {
138: line = (LINENO) exp->right->lconval;
139: addr = objaddr(line, exp->left->sconval);
140: } else {
141: line = (LINENO) exp->lconval;
142: addr = objaddr(line, cursource);
143: }
144: if (addr == (ADDRESS) -1) {
145: error("can't trace line %d", line);
146: }
147: }
148: tfree(exp);
149: addbp(addr, INST, NIL, cond, NIL, line);
150: }
151:
152: /*
153: * set a breakpoint to print an expression at a given line or address
154: */
155:
156: LOCAL traceat(cmd, exp, where, cond)
157: int cmd;
158: NODE *exp;
159: NODE *where;
160: NODE *cond;
161: {
162: LINENO line;
163: ADDRESS addr;
164:
165: if (cmd == O_TRACEI) {
166: if (where->op != O_LCON) {
167: trerror("expected integer constant, found %t", where);
168: }
169: line = -1;
170: addr = (ADDRESS) where->lconval;
171: } else {
172: line = (LINENO) where->right->lconval;
173: addr = objaddr(line, where->left->sconval);
174: if (addr == (ADDRESS) -1) {
175: error("can't trace at line %d", line);
176: }
177: }
178: addbp(addr, AT_BP, NIL, cond, exp, line);
179: }
180:
181: /*
182: * Set up breakpoint for tracing data.
183: *
184: * The tracing of blocks lies somewhere between instruction and data;
185: * it's here since a block cannot be distinguished from other terms.
186: *
187: * As in "traceall", if the "block" is the main program then the
188: * user didn't actually specify a block. This means we want to
189: * turn tracing on ourselves because if the program is stopped
190: * we want to be on regardless of whether they say "cont" or "run".
191: */
192:
193: LOCAL tracedata(cmd, exp, block, cond)
194: int cmd;
195: NODE *exp;
196: NODE *block;
197: NODE *cond;
198: {
199: SYM *s, *t;
200:
201: if (exp->op != O_RVAL && exp->op != O_CALL) {
202: error("can't trace expressions");
203: }
204: if (block == NIL) {
205: t = tcontainer(exp->left);
206: } else if (block->op == O_NAME) {
207: t = block->nameval;
208: } else {
209: trerror("found %t, expected procedure or function", block);
210: }
211: if (exp->left->op == O_NAME) {
212: s = exp->left->nameval;
213: if (isblock(s)) {
214: addbp(codeloc(t), BLOCK_ON, t, cond, exp->left, 0);
215: if (t == program) {
216: addbp(codeloc(s), CALL, s, cond, NIL, 0);
217: }
218: return;
219: }
220: }
221: addbp(codeloc(t), TERM_ON, t, cond, exp, 0);
222: if (curfunc == t) {
223: var_tracing++;
224: addvar(TRPRINT, exp, cond);
225: addbp(return_addr(), TERM_OFF, t, cond, exp, 0);
226: }
227: }
228:
229: /*
230: * Setting and unsetting of stops.
231: */
232:
233: stop(cmd, exp, where, cond)
234: int cmd;
235: NODE *exp;
236: NODE *where;
237: NODE *cond;
238: {
239: SYM *s;
240: LINENO n;
241:
242: if (exp != NIL) {
243: stopvar(cmd, exp, where, cond);
244: } else if (cond != NIL) {
245: if (where == NIL) {
246: s = program;
247: } else if (where->op == O_NAME) {
248: s = where->nameval;
249: } else {
250: error("bad location for stop");
251: }
252: n = codeloc(s);
253: addbp(n, STOP_ON, s, cond, NIL, n);
254: addcond(TRSTOP, cond);
255: var_tracing++;
256: } else if (where->op == O_NAME) {
257: s = where->nameval;
258: if (!isblock(s)) {
259: error("\"%s\" is not a procedure or function", name(s));
260: }
261: n = codeloc(s);
262: addbp(n, STOP_BP, s, cond, NIL, srcline(firstline(s)));
263: } else {
264: stopinst(cmd, where, cond);
265: }
266: if (where != NIL) {
267: tfree(where);
268: }
269: }
270:
271: LOCAL stopinst(cmd, where, cond)
272: int cmd;
273: NODE *where;
274: NODE *cond;
275: {
276: LINENO line;
277: ADDRESS addr;
278:
279: if (where->op != O_QLINE) {
280: error("expected line number");
281: }
282: if (cmd == O_STOP) {
283: line = (LINENO) where->right->lconval;
284: addr = objaddr(line, where->left->sconval);
285: if (addr == (ADDRESS) -1) {
286: error("can't stop at that line");
287: }
288: } else {
289: line = -1;
290: addr = (ADDRESS) where->right->lconval;
291: }
292: addbp(addr, STOP_BP, NIL, cond, NIL, line);
293: }
294:
295: /*
296: * Implement stopping on assignment to a variable by adding it to
297: * the variable list.
298: */
299:
300: LOCAL stopvar(cmd, exp, where, cond)
301: int cmd;
302: NODE *exp;
303: NODE *where;
304: NODE *cond;
305: {
306: SYM *s;
307:
308: if (exp->op != O_RVAL) {
309: trerror("found %t, expected variable", exp);
310: }
311: if (cmd == O_STOPI) {
312: inst_tracing++;
313: }
314: var_tracing++;
315: addvar(TRSTOP, exp, cond);
316: if (where == NIL) {
317: s = program;
318: } else if (where->op == O_NAME) {
319: s = where->nameval;
320: } else {
321: error("bad location for stop");
322: }
323: addbp(codeloc(s), STOP_ON, s, cond, exp, 0);
324: }
325:
326: /*
327: * Figure out the block that contains the symbols
328: * in the given variable expression.
329: */
330:
331: LOCAL SYM *tcontainer(var)
332: NODE *var;
333: {
334: NODE *p;
335:
336: p = var;
337: while (p->op != O_NAME) {
338: if (isleaf(p->op)) {
339: panic("unexpected op %d in tcontainer", p->op);
340: /* NOTREACHED */
341: }
342: p = p->left;
343: }
344: return container(p->nameval);
345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.