![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to single.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb|
Return to single.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb |
1.1 root 1: static char sccsid[] = "@(#)single.c 2.8";
2:
3: #include "cdb.h"
4:
5:
6: extern char vsbArgsChild[]; /* defined in pt.c */
7:
8: export int vcBadMax; /* most instructions we single step without symbols */
9:
10: typedef struct { /* the assertion descriptor */
11: char *sbCheck; /* points to command list for this check */
12: ASE as; /* state of THIS assertion check */
13: }
14: ADR, *pADR;
15: #define cbADR sizeof(ADR)
16:
17: pADR vrgAd; /* the list of assertions */
18: ADRT vpcLast;
19: export int viadMac, viadMax;
20: export FLAGT vfRunAssert; /* see IbpFNewChild */
21: export ASE vas; /* state of the assertions as a whole */
22:
23:
24:
25: /* A D R F S T A C K F I X */
26:
27: export ADRT AdrFStackFix(adr)
28: ADRT adr;
29: {
30: /* given an address immediately after a procedure call, step over any
31: * stack fix-up instructions
32: */
33: #ifdef ONYX
34: int inst;
35: #define INCR15_INST 0xa900
36: inst = GetWord(adr, spaceText);
37: if ((inst & 0xff00) == INCR15_INST)
38: adr += 2;
39: #endif
40: #ifdef TAHOE
41: /* TAHOE has no stack fix stuff, it's all done by the callee */
42: #endif
43: #ifdef VAX
44: /* vax has no stack fix stuff, it's all done by the callee */
45: #endif
46: #ifdef M68000
47: short inst;
48:
49: #define TST_INST 0x4a5f
50: #define TSTL_INST 0x4a9f
51: #define CMPML_INST 0xbf8f
52: #define ADDW_INST 0xdefc
53: #define ADDQ_INST 0x500f
54: #define ADDN_INST 0x504f
55:
56: GetBlock(adr, spaceText, &inst, 2);
57: if ( (inst == TST_INST)
58: OR (inst == TSTL_INST)
59: OR (inst == CMPML_INST)
60: OR ((inst & 0xf13f) == ADDQ_INST))
61: adr += 2;
62: else if ((inst & 0xf1ff) == ADDN_INST)
63: adr += 4;
64: #endif
65: return(adr);
66: } /* AdrFStackFix */
67:
68:
69: /* A D R F P R E A M B L E */
70:
71: local ADRT AdrFPreamble(adr)
72: ADRT adr;
73: {
74: /* given the first address in a procedure, return the address of the
75: * first `real' instruction - ie. after the csav0 or the brb whatever
76: */
77: #ifdef ONYX
78: int inst;
79:
80: #define LDK_INST 0xbd00
81: #define LD_INST 0x2100
82: inst = GetWord(adr, spaceText) & 0xff00; /* high byte of 1st instruction */
83: /* we want to skip over stack set up stuff */
84: adr += (inst == LDK_INST) ? 6 : (inst == LD_INST) ? 8 : 4;
85: #endif
86: #ifdef TAHOE
87: int inst, specifier;
88:
89: #define BRB_INST 0x11 /* Guess they are the only ones after mask */
90: #define BRW_INST 0x13
91: #define JMP_INST 0x71
92: #define SUBL3_INST 0x3c
93: inst = GetByte(adr, spaceText) & 0xff; /* instruction */
94: specifier = GetByte((char *)adr + 1, spaceText) & 0xff; /* operand spec */
95: /* we want to skip over stack set up stuff */
96: switch (inst) {
97: case BRB_INST:
98: adr += 2;
99: break;
100: case BRW_INST:
101: adr += 3;
102: break;
103: case JMP_INST:
104: adr += 6;
105: break;
106: case SUBL3_INST:
107: if (specifier <= 63) adr += 4 ;
108: else switch (specifier) {
109: case 0x88:
110: adr += 5;
111: break;
112: case 0x89:
113: adr += 6;
114: break;
115: case 0x8f:
116: adr += 8;
117: break;
118: }
119: break;
120: default:
121: printf("CDB problem - unexpected instruction (0x%0x) at procedure begining\n", inst);
122: }
123: #endif
124:
125: #ifdef VAX
126: int inst;
127:
128: #define BRB_INST 0x11
129: #define BRW_INST 0x31
130: #define JMP_INST 0x17
131: #define SUBL2_INST 0xc2
132: inst = GetByte(adr, spaceText) & 0xff; /* instruction */
133: /* we want to skip over stack set up stuff */
134: if (inst == BRB_INST)
135: adr += 2;
136: else if (inst == BRW_INST)
137: adr += 3;
138: else if (inst == SUBL2_INST)
139: adr += 7;
140: else
141: adr += 4;
142: #endif
143: #ifdef M68000
144: int ipd, iln, ifd, slop;
145:
146: ipd = IpdFAdr(adr);
147: if (ipd != ipdNil) {
148: IfdLnFAdr(adr, vrgPd[ipd].isym+1, &ifd, &iln, &slop);
149: #ifdef SUN
150: iln++; /* first line number is connected with preamble */
151: #endif
152: adr = AdrFIfdLn(ifd, iln);
153: } /* if */
154: #endif
155: return(adr);
156: } /* AdrFPreamble */
157:
158:
159: /* F A T C A L L */
160:
161: local FLAGT FAtCall(adr)
162: ADRT adr;
163: {
164: short inst;
165: /* return true or false based on whether the instruction at adr
166: * is a procedure call of any kind.
167: */
168: inst = 0;
169: #ifdef ONYX
170: #define CALL_INST 0x5f00
171: #define cbInsMax 2
172: GetBlock(adr, spaceText, (ADRT)&inst, cbInsMax);
173: return(inst == CALL_INST);
174: #endif
175:
176: #ifdef TAHOE
177: #define CALLS_INST 0xbf
178: #define CALLG_INST 0xfe
179: GetBlock(adr, spaceText, ((char *)&inst)+1, 1);
180: return((inst == CALLS_INST) OR (inst == CALLG_INST));
181: #endif
182:
183: #ifdef VAX
184: #define CALLS_INST 0xfb /* arguments are on the stack */
185: #define CALLG_INST 0xfa /* arguments are elsewhere */
186: GetBlock(adr, spaceText, &inst, 1);
187: return((inst == CALLS_INST) OR (inst == CALLG_INST));
188: #endif
189:
190: #ifdef M68000
191: #define JSR_INST 0x4e80
192: #define BSR_INST 0x6100
193: #define cbInsMax 2
194:
195: GetBlock(adr, spaceText, (ADRT)&inst, cbInsMax);
196: return(((inst & 0xff00) == BSR_INST) OR ((inst & 0xffc0) == JSR_INST));
197: #endif
198: } /* FAtCall */
199:
200:
201: /* R E T F S P */
202:
203: local ADRT RetFSp(sp)
204: ADRT sp;
205: {
206: /* given the stack pointer immediately after a procedure call,
207: * return the return address
208: */
209: #ifdef TAHOE
210: /* We know that the argument here is realy 'fp', not 'sp'. */
211: return(GetWord(sp-8, spaceData)); /* get return */
212: #endif
213: #ifdef VAX
214: return(GetWord(sp+16, spaceData)); /* get return */
215: #endif
216: #ifdef ONYX
217: return(GetWord(sp, spaceData)); /* get return */
218: #endif
219: #ifdef M68000
220: return(GetWord(sp, spaceData)); /* get return */
221: #endif
222: } /* RetFSp */
223:
224:
225: /* R E T F F P */
226:
227: local ADRT RetFFp(fp)
228: ADRT fp;
229: {
230: ADRT ap, pc;
231: /* given a frame pointer, return the return address */
232: NextFrame(&fp, &ap, &pc);
233: return(pc); /* get return */
234: } /* RetFFp */
235:
236:
237: /* I B P F S I N G L E */
238:
239: export int IbpFSingle(fBigStep, fQuiet)
240: FLAGT fBigStep, fQuiet;
241: {
242: int cBad, ibp, ifd, ln, slop;
243: ADRT adr;
244:
245: if (vpid == pidNil) {
246: /* we have no process, create one! */
247: IbpFNewChild(vsbArgsChild);
248: PrintPos(vpc, (fQuiet) ? fmtNil : fmtProc+fmtLn+fmtPrint);
249: return(vibp);
250: } /* if */
251:
252: /* the idea here is to loop until we get someplace interesting. This
253: * usually means at an address that translates EXACTLY (slop == 0) to
254: * a known line number.
255: */
256: cBad = 0; /* to count instructions in the twilight zone */
257: slop = -1; /* just to get us into loop first time */
258: while (slop != 0) {
259: ibp = ibpNil;
260: if (FAtCall(vpc)) { /* at proc call */
261: /* follow the call - this way we don't have to deal with N ways
262: * to compute callee's address.
263: */
264: ibp = IbpFRun(ptSingle);
265: if (ibp != ibpNil)
266: return(ibp); /* a REAL breakpoint */
267: if (!fBigStep) {
268: if (IpdFAdr(vpc) != ipdNil) {
269: adr = AdrFPreamble(vpc); /* allows for intro code */
270: ibp = IbpFAdr(adr, 0, sbNil); /* temp BP after intro */
271: ibp = IbpFRun(ptResume);
272: break; /* go to the stuff at end of this procedure */
273: } /* if */
274: /* if we get here, then the proc call goes to the
275: * twilight zone - fall into fBigStep code
276: */
277: } /* if */
278: #ifdef TAHOE
279: adr = AdrFStackFix(RetFSp(vfp));
280: #else
281: adr = AdrFStackFix(RetFSp(vsp));
282: #endif
283: ibp = IbpFAdr(adr, 0, sbNil); /* temp BP at return */
284: ibp = IbpFRun(ptResume);
285: }
286: else { /* NOT at a procedure call */
287: if ((ibp = IbpFRun(ptSingle)) != ibpNil)
288: return(ibp); /* a REAL breakpoint, so it MUST be kosher! */
289: if (IpdFAdr(vpc) != ipdNil) {
290: cBad = 0;
291: }
292: else {
293: /* we are in a file without good symbols */
294: /* KLUDGE! There is a problem here.
295: * Some trips to boony land are short, like the switch code
296: * for Onyx, some are MUCH longer, like the printf code.
297: * What we do is go along with the joke for up to
298: * vcBadMax `bad' instructions. If we don't see daylight, we
299: * set an up level break from the (hopefully good) return
300: * address. There are NO GUARANTEES that this is correct,
301: * but it seems to work MOST of the time.
302: */
303: if (++cBad >= vcBadMax) {
304: /* set uplevel break and wait for it to come home */
305: adr = RetFFp(vfp); /* get return */
306: ibp = IbpFAdr(adr, 0, sbNil);
307: ibp = IbpFRun(ptResume);
308: } /* if */
309: slop = -1;
310: } /* if */
311: } /* if */
312: if ( (ibp != ibpNil) OR (vpid == pidNil) )
313: return(ibp);
314: if (cBad == 0)
315: IfdLnFAdr(vpc, isym0, &ifd, &ln, &slop);
316: } /* while */
317:
318: if ((vpid != pidNil) AND (ibp == ibpNil))
319: PrintPos(vpc, (fQuiet) ? fmtNil : fmtProc+fmtLn+fmtPrint);
320: return(ibp);
321: } /* IbpFSingle */
322:
323:
324: /* these routines maintain the list of assertions.
325: * since the presence of even ONE assertion forces the
326: * child process to singlestep, they should only be used
327: * when your back is against the wall e.g. someone is stepping
328: * on a global and you don't know who!
329: */
330:
331:
332: /* I N I T A S S E R T */
333:
334: export void InitAssert()
335: {
336: viadMac = 0;
337: vrgAd = (pADR) malloc(viadMax * cbADR);
338: vcbTot += viadMax * cbADR;
339: vas = asActive;
340: } /* InitAssert */
341:
342:
343: /* L I S T A S S E R T */
344:
345: export void ListAssert()
346: {
347: int i;
348:
349: if (viadMac == 0)
350: UError("No assertions");
351: printf("Assertions in general are %s\n\n",
352: (vas == asActive) ? "ACTIVE" : "SUSPENDED");
353: for (i=0; i < viadMac; i++) {
354: printf("%2d: %s %s\n", i,
355: (vrgAd[i].as==asActive) ? "Active" : "Suspended", vrgAd[i].sbCheck);
356: } /* for */
357: } /* ListAssert */
358:
359:
360: /* A D D A S S E R T */
361:
362: export void AddAssert(sbCheck)
363: char *sbCheck;
364: {
365: int cb, iad;
366:
367: if (viadMac >= viadMax)
368: UError("Too many assertions");
369: iad = viadMac++;
370: cb = strlen(sbCheck);
371: vrgAd[iad].sbCheck = malloc(cb+1); /* room for null */
372: vcbTot += cb + 1;
373: strcpy(vrgAd[iad].sbCheck, sbCheck);
374: vrgAd[iad].sbCheck[cb] = chNull;
375: vrgAd[iad].as = asActive;
376: printf("Assertion %d: Active \"%s\"\n", iad, vrgAd[iad].sbCheck);
377: vas = asActive;
378: printf("Assertions are ACTIVE");
379: } /* AddAssert */
380:
381:
382: /* M O D A S S E R T */
383:
384: export void ModAssert(iad, as)
385: int iad;
386: ASE as;
387: {
388: if (iad < 0 OR iad >= viadMac)
389: UError("Bad assertion number: %d", iad);
390: vrgAd[iad].as = as;
391: if (as == asNil) {
392: free(vrgAd[iad].sbCheck);
393: vrgAd[iad] = vrgAd[viadMac-1]; /* fold it back on itself */
394: viadMac--;
395: }
396: if (vas == asSuspended)
397: return;
398: for (iad = 0; iad < viadMac; iad++)
399: if (vrgAd[iad].as == asActive)
400: return;
401: printf("Assertions are ACTIVE");
402: vas = asSuspended;
403: } /* ModAssert */
404:
405:
406: /* F D O A S S E R T */
407:
408: export void FDoAssert(pt)
409: int pt;
410: {
411: int iad;
412: long cnt;
413:
414: vfRunAssert = false; /* so we are not recursive entered from IbpFRun */
415: PushCmd(vsbCmd); /* save what we are doing */
416: for (cnt=(pt==ptSingle) ? 1 : -1;cnt != 0; --cnt) {
417: /* we do the assertions BEFORE the line is executed */
418: for(iad=0; iad < viadMac; iad++) {
419: if ((vrgAd[iad].as == asActive)
420: AND (FDoCommand(vrgAd[iad].sbCheck, false))) {
421: /* we hit an 'x' (exit) command - stop the parade! */
422: printf("\nHit on assertion %d: \"%s\"\n",
423: iad, vrgAd[iad].sbCheck);
424: printf("Last line executed was:\n");
425: PrintPos(vpcLast, fmtFile+fmtProc+fmtLn+fmtPrint+fmtSave);
426: printf("Next line to execute is:\n");
427: PrintPos(vpc, fmtFile+fmtProc+fmtLn+fmtPrint);
428: vfRunAssert = true;
429: return(true);
430: } /* if */
431: } /* for */
432: vpcLast = vpc; /* remember where the current line is */
433: /* step the process one statement's worth */
434: if (ibpNil != IbpFSingle(false, true)) {
435: vfRunAssert = true;
436: return(false);
437: } /* if */
438: } /* for */
439: PrintPos(vpc, fmtNil); /* restore our context */
440: vfRunAssert = true;
441: return(false);
442: } /* FDoAssert */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.