![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mchframe.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / adb / vax|
Return to mchframe.c CVS log | Up to [Research Unix] / researchv9 / cmd / adb / vax |
1.1 root 1: /*
2: * machine-dependent code for
3: * looking in stack frames
4: * vax version
5: */
6:
7: #include "defs.h"
8: #include <sys/param.h>
9: #include "regs.h"
10: #include "sym.h"
11: #include "space.h"
12:
13: int maxargs = 20;
14:
15: /*
16: * VAX stack frame
17: */
18:
19: #define F_PSW 4
20: #define F_FLAGS 6
21: #define F_AP 8 /* saved ap */
22: #define F_FP 12 /* saved fp */
23: #define F_PC 16 /* return pc */
24: #define F_REGS 20 /* saved regs, if any */
25:
26: /*
27: * flags
28: */
29:
30: #define FFREGS 0x1fff /* saved register flags; 01 is r0 */
31: #define FFCALLS 0x2000 /* called by calls, not callg */
32: #define FFOFF 0xc000 /* offset added to align stack */
33: #define SALIGN(f) (((f)>>14) & 03)
34:
35: /*
36: * is the saved psw reasonable?
37: * really just a last resort to find the end of the stack
38: */
39:
40: #define BADPSW(p) (((p)&0xff00) != 0)
41:
42: /*
43: * is the pc probably in signal trampoline code?
44: * == it's in the user block
45: */
46:
47: #define sigtramp(pc) (0x80000000 > (pc) && (pc) > 0x80000000 - ctob(UPAGES))
48:
49: #define F_HACK 64 /* where to find the saved pc in a trampoline frame */
50: /*
51: * return an address for a local variable
52: * no register vars, unfortunately, as we can't provide an address
53: * gn is the procedure; ln the local name
54: *
55: * this is vax dependent because symbol tables vary
56: */
57:
58: localaddr(gn, ln)
59: char *gn, *ln;
60: {
61: WORD fp, ap;
62: extern WORD expv;
63: extern int expsp;
64: ADDR laddr();
65:
66: if (gn) {
67: if (findrtn(gn) == 0)
68: error("function not found");
69: }
70: else {
71: findsym((WORD)atow(rget(PC)), INSTSP);
72: if (cursym == NULL)
73: error("function not found");
74: }
75: if (findframe(&fp, &ap) == 0)
76: error("stack frame not found");
77: if (ln == NULL) {
78: expsp = 0;
79: expv = fp;
80: return;
81: }
82: while (localsym()) {
83: if (strcmp(ln, cursym->y_name) != 0)
84: continue;
85: expv = laddr(cursym, fp, ap);
86: if (cursym->y_ltype == S_RSYM)
87: expsp = REGSP;
88: else
89: expsp = NOSP;
90: return;
91: }
92: error("bad local variable");
93: /* NOTREACHED */
94: }
95:
96: /*
97: * print a stack traceback
98: * give locals if possible
99: */
100:
101: ctrace(modif)
102: char modif;
103: {
104: register ADDR fp, ap, callpc;
105: register int narg;
106: ADDR oap;
107: register int fl;
108: int tramp;
109:
110: if (adrflg) {
111: fp = adrval;
112: fl = stow(sget(fp + F_FLAGS, CORF|DATASP));
113: if ((fl & FFCALLS) == 0)
114: ap = fp; /* callg, can't figure out ap */
115: else {
116: ap = adrval + F_REGS + SALIGN(fl);
117: fl &= FFREGS;
118: while (fl) {
119: if (fl & 1)
120: ap += SZREG;
121: fl >>= 1;
122: }
123: }
124: callpc = atow(aget(fp + F_PC, CORF|DATASP));
125: } else {
126: ap = (ADDR)rtow(rget(AP));
127: fp = (ADDR)rtow(rget(FP));
128: callpc = (ADDR)rtow(rget(PC));
129: }
130: clrraddr();
131: while (cntval--) {
132: chkerr();
133: tramp = 0;
134: if (sigtramp(callpc)) {
135: printf("sigtramp(");
136: tramp++;
137: } else {
138: findsym(callpc, INSTSP);
139: if (cursym == NULL)
140: printf("?(");
141: else if (strcmp("start", cursym->y_name) == 0)
142: break;
143: else
144: printf("%s(", cursym->y_name);
145: }
146: fl = ctow(cget(ap, CORF|DATASP));
147: if ((narg = fl) > maxargs)
148: narg = maxargs;
149: oap = ap;
150: while (--fl, --narg >= 0) {
151: printf("%R", ltow(lget(ap += SZREG, CORF|DATASP)));
152: if (narg != 0)
153: printc(',');
154: }
155: if (fl >= 0)
156: printf(",...");
157: printf(") from %R\n", callpc);
158: if (modif == 'C')
159: locals(fp, oap);
160: if (tramp) /* hack */
161: callpc = atow(aget(fp + F_HACK, CORF|DATASP));
162: else
163: callpc = atow(aget(fp + F_PC, CORF|DATASP));
164: fl = stow(sget(fp + F_FLAGS, CORF|DATASP));
165: setraddr(fl, fp);
166: ap = atow(aget(fp + F_AP, CORF|DATASP));
167: fp = atow(aget(fp + F_FP + SALIGN(fl), CORF|DATASP));
168: if (fp == 0)
169: break;
170: fl = stow(sget(fp + F_PSW, CORF|DATASP));
171: if (BADPSW(fl))
172: break;
173: }
174: clrraddr();
175: }
176:
177: static
178: locals(fp, ap)
179: ADDR fp, ap;
180: {
181: WORD val;
182: register int sp;
183: ADDR laddr();
184:
185: while (localsym()) {
186: sp = CORF | DATASP;
187: if (cursym->y_ltype == S_RSYM)
188: sp = CORF | REGSP;
189: val = ltow(lget(laddr(cursym, fp, ap), sp));
190: if (errflg == 0)
191: printf("%8t%s/%10t%R\n", cursym->y_name, val);
192: else {
193: printf("%8t%s/%10t?\n", cursym->y_name);
194: errflg = 0;
195: }
196: }
197: }
198:
199: static ADDR
200: laddr(sp, fp, ap)
201: struct sym *sp;
202: ADDR fp, ap;
203: {
204:
205: switch (sp->y_ltype) {
206: case S_STSYM:
207: return (sp->y_value);
208:
209: case S_LSYM:
210: return (fp - sp->y_value);
211:
212: case S_PSYM:
213: return (ap + sp->y_value);
214:
215: case S_RSYM:
216: return (sp->y_value * SZREG);
217: }
218: error("bad local symbol");
219: /* NOTREACHED */
220: }
221:
222: static int
223: findframe(fpp, app)
224: ADDR *fpp, *app;
225: {
226: register ADDR fp, ap, pc;
227: register int fl;
228: struct sym *svcur;
229:
230: svcur = cursym;
231: fp = rtow(rget(FP));
232: ap = rtow(rget(AP));
233: pc = rtow(rget(PC));
234: if (errflg)
235: return (0);
236: clrraddr();
237: for (;;) {
238: findsym(pc, INSTSP);
239: if (cursym == svcur)
240: break;
241: if (cursym && strcmp(cursym->y_name, "start") == 0) {
242: clrraddr();
243: return (0);
244: }
245: fl = stow(sget((ADDR)fp + F_FLAGS, CORF|DATASP));
246: setraddr(fl, fp);
247: pc = atow(aget(fp + F_PC, CORF|DATASP));
248: ap = atow(aget(fp + F_AP, CORF|DATASP));
249: fp = atow(aget(fp + F_FP + SALIGN(fl), CORF|DATASP));
250: /* sigtramp? */
251: if (errflg) {
252: clrraddr();
253: return (0);
254: }
255: }
256: *fpp = fp;
257: *app = ap;
258: return (1);
259: }
260:
261: /*
262: * set addresses for saved registers for this frame
263: */
264:
265: static
266: setraddr(mask, fp)
267: register int mask;
268: register ADDR fp;
269: {
270: register int r;
271: register int i;
272: extern ADDR raddr[];
273:
274: mask &= FFREGS;
275: for (r = 0, i = 0; mask; r++)
276: if (mask & (1 << r)) {
277: if (MINREG <= r && r <= MAXREG)
278: raddr[r - MINREG] = fp + F_REGS +
279: i * SZREG;
280: i++;
281: mask &=~ (1 << r);
282: }
283: }
284:
285: static
286: clrraddr()
287: {
288: register int i;
289: extern ADDR raddr[];
290:
291: for (i = 0; i <= MAXREG - MINREG; i++)
292: raddr[i] = 0;
293: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.