![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i386db1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db / i386|
Return to i386db1.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db / i386 |
1.1 root 1: /*
2: * db/i386/i386db1.c
3: * A debugger.
4: * i386-specific code.
5: * This file contains all the routines called by the machine-independent code
6: * except disassemble(), which is in i386db2.c.
7: */
8:
9: #include <sys/ptrace.h>
10: #include <sys/sysi86.h>
11: #include <errno.h>
12: #include "i386db.h"
13:
14: /*
15: * Get the return pc and frame pointer to set a return breakpoint.
16: * Like traceback(), this knows some gory details about the calling sequence;
17: * see the comment there for elucidation.
18: * At a function entry point,
19: * %ebp is the caller's stack frame and *%esp contains the ra.
20: * Inside a function (after the frame save),
21: * *%ebp is the caller's stack frame and the ra is at a fixed offset from %ebp.
22: */
23: int
24: bpt_setr(cmd) char *cmd;
25: {
26: register ADDR_T sp, myfp;
27: ADDR_T ra, fp;
28: unsigned char b;
29:
30: add = get_pc();
31: fp = get_fp();
32: sp = get_sp();
33: dbprintf(("bpt_setr(%s) ip=%X bp=%X sp=%X\n", cmd, add, fp, sp));
34:
35: /* Fetch the next opcode. */
36: if (getb(ISEG, &b, sizeof(b)) == 0)
37: return 0; /* opcode fetch failed */
38:
39: /* Find the return address and the caller's stack frame. */
40: if ((IS_LOUT && b == PUSHESI)
41: || (!IS_LOUT && (b==ENTER || b==PUSHEBP)))
42: add = sp; /* sp points at ra, fp ok */
43: else {
44: add = myfp = fp; /* fetch caller's fp */
45: if (get_sized(DSEG, &fp) == 0)
46: return 0;
47: add = myfp + (IS_LOUT) ? 6 : 4; /* ra at known offset off fp */
48: }
49:
50: /* Fetch the return address. */
51: if (get_sized(DSEG, &ra) == 0)
52: return 0; /* ra fetch failed */
53: dbprintf(("placing BRET breakpoint: ra=%X fp=%X cmd=%s\n", ra, fp, cmd));
54: return bpt_set(BRET, ra, fp, cmd); /* set the return bpt */
55: }
56:
57: /*
58: * See if the given instruction is a breakpoint.
59: */
60: int
61: bpt_test(pc) ADDR_T pc;
62: {
63: unsigned char w;
64:
65: dbprintf(("bpt_test(%x)\n", pc));
66: add = pc;
67: return getb(ISEG, &w, sizeof(w))!=0 && w==TRAP;
68: }
69:
70: /*
71: * Display registers.
72: * The 'flag' arg is R_GEN to get the general registers
73: * or R_ALL to get all the registers (including NDP).
74: */
75: void
76: display_reg(flag) int flag;
77: {
78: register REGNAME *rp;
79: register ADDR_T val;
80: register char *name;
81: register int n;
82:
83: if (testint())
84: return;
85:
86: if (get_regs(flag) == 0)
87: return;
88:
89: for (n = 0, rp = reg_name; rp < ®_name[NGREGS]; rp++) {
90:
91: if (testint())
92: return;
93:
94: /* Print register name. */
95: name = rp->r_name;
96: if (IS_LOUT) {
97: if (*name == 'e' && strlen(name) == 3)
98: ++name;
99: printx("%%%-2s=", name);
100: } else
101: printx("%%%-3s=", name);
102:
103: /* Print contents. */
104: val = *(ADDR_T *)(((char *)&ureg) + rp->r_offset);
105: switch(rp->r_flag) {
106: case RF_1632:
107: if (!IS_LOUT) {
108: printx(ADDR_FMT, val);
109: break;
110: }
111: /* else fall through... */
112: case RF_16:
113: printx(ADDR16_FMT, val&0xFFFF);
114: break;
115: default:
116: printr("<flag=%x>", rp->r_flag);
117: }
118: putchar(((++n % 4) == 0 || n == NGREGS) ? '\n' : '\t');
119: }
120:
121: #ifndef NOFP
122: /*
123: * Dump the NDP state for :rN.
124: * Thanks to hal for this code,
125: * more detail than the average user needs...
126: */
127: if (flag == R_ALL) {
128: register struct _fpstate *fstp;
129: register int i;
130: #if 0
131: register int j;
132: #endif
133: int tagbits, tos;
134: unsigned char opfirst, opsecond;
135: unsigned int fcs, exp, sigzero;
136: double d;
137:
138: fstp = &ureg.ur_fpstate;
139: fcs = fstp->cssel;
140: tos = (fstp->sw >> 11) & 7;
141: #if 0
142: printx("\nfstp=%08X\ttos=%d ", fstp, tos);
143: #endif
144: opfirst = 0xD8 | ((fcs >> 24) & 7);
145: opsecond = fcs >> 16;
146: #if 0
147: printx("cw=%04X\tsw=%04X\ttag=%04X\n",
148: fstp->cw&0xFFFF, fstp->sw&0xFFFF, fstp->tag&0xFFFF);
149: printx("op=%02X\t%02X\tfcs=%04X\tfip=%08X\tfos=%04X\tfoo=%08X\n",
150: opfirst, opsecond,
151: fcs&0xFFFF, fstp->ipoff, fstp->datasel&0xFFFF, fstp->dataoff);
152: #endif
153: if (testint())
154: return;
155: for (i = 0; i < 8; i++) {
156: tagbits = (fstp->tag >> (((tos + i) & 7) * 2)) & 3;
157: printx("%%st%d=", i);
158: #if 0
159: printx("(%d) at %08X ", tagbits, fstp->_st + i);
160: #endif
161: switch(tagbits) {
162: case 0: /* Normal */
163: if (get_fp_reg(&fstp->_st[i], &d) == 0)
164: printx("(none)"); /* no NDP */
165: else
166: printx("%g", d);
167: #if 0
168: for (j = 0; j < 4; j++)
169: printx("%04X ", fstp->_st[i].significand[j]);
170: printx(":%04X\n", fstp->_st[i].exponent);
171: #endif
172: break;
173: case 1: /* Zero */
174: printx("0.0");
175: break;
176: case 2: /* NaN, Infinity, Denormal */
177: exp = fstp->_st[i].exponent;
178: sigzero = (fstp->_st[i].significand[0] == 0
179: && fstp->_st[i].significand[1] == 0
180: && fstp->_st[i].significand[2] == 0
181: && fstp->_st[i].significand[3] == 0x8000);
182: putx((exp & 0x8000) ? '-' : '+');
183: exp &= 0x7FFF;
184: if (exp == 0x7FFF)
185: printx(sigzero ? "Infinity" : "NaN");
186: else if (exp == 0 && !sigzero)
187: printx("Denormal");
188: else /* shouldn't happen */
189: printx("Special: %08X %08X %08X %08X : %08X\n",
190: fstp->_st[i].significand[0],
191: fstp->_st[i].significand[1],
192: fstp->_st[i].significand[2],
193: fstp->_st[i].significand[3],
194: fstp->_st[i].exponent);
195: break;
196: case 3: /* Empty */
197: printx("<Empty>");
198: break;
199: }
200: if (i==3 || i==7)
201: putx('\n');
202: else
203: putx('\t');
204: }
205: }
206: #endif
207: }
208:
209: /*
210: * Find the segment in which an address resides.
211: * For COFF, the address implies a unique segment (or SEG_NONE).
212: * For l.out, the same address can represent an item in either DSEG or ISEG
213: * (i.e. the address->segment mapping is one->many), so this is does not
214: * necessarily give the right answer; it is even less right since the
215: * segmentation maps for the child process are at present set up incorrectly.
216: * Return SEG_NONE if not found.
217: */
218: int
219: find_seg(addr) register ADDR_T addr;
220: {
221: register int s;
222:
223: if (IS_COFF)
224: return (addr < (ADDR_T)0x00400000) ? ISEG
225: : (addr < (ADDR_T)0x80000000) ? DSEG
226: : SEG_NONE;
227: for (s = 0; s < NSEGS; s++)
228: if (map_addr(s, addr) != (MAP *)NULL)
229: return s;
230: return SEG_NONE;
231: }
232:
233: /*
234: * Given a size character 't1' and a type 't2',
235: * return the appropriate format string.
236: */
237: char *
238: get_format(t1, t2) register int t1, t2;
239: {
240: register char *cp, *sp;
241:
242: if (t1 == 'f' || t1 == 'F')
243: return "%g";
244: if (t1 == 'h')
245: t1 = 'w';
246: if ((cp = strchr(sp = "bwlv", t1)) == NULL)
247: return "?";
248: t1 = cp - sp;
249: if ((cp = strchr(sp = "duox", t2)) == NULL)
250: return "?";
251: t2 = cp - sp;
252: return formtab[t1][t2];
253: }
254:
255: /*
256: * Return the frame pointer.
257: * Mask to 16-bit value for l.out.
258: */
259: ADDR_T
260: get_fp()
261: {
262: return (IS_LOUT) ? ureg.ur_bp & 0xFFFF : ureg.ur_bp;
263: }
264:
265: /*
266: * Store the value from an NDP register into a double.
267: * If the machine has no NDP, fail and return 0.
268: * If the machine has an NDP (or NDP emulation),
269: * use the coprocessor instructions in _get_fp_reg()
270: * to convert the 80-bit arg to the 64-bit result
271: * and return 1.
272: */
273: int
274: get_fp_reg(fpregp, dp) struct _fpreg *fpregp; double *dp;
275: {
276: if (!NDP_flag)
277: return 0; /* sorry */
278: *dp = _get_fp_reg(fpregp); /* store converted result */
279: return 1;
280: }
281:
282: /*
283: * Return the program counter.
284: * Mask to 16-bit value for l.out.
285: */
286: ADDR_T
287: get_pc()
288: {
289: return (IS_LOUT) ? ureg.ur_ip & 0xFFFF : ureg.ur_ip;
290: }
291:
292: /*
293: * Read registers from the child process.
294: * The flag is:
295: * R_SOME read %eip, %ebp, %esp and signal number only
296: * R_GEN read the general registers
297: * R_ALL read all the registers, general and NDP
298: * This is for efficiency; the values of the registers other than ip/bp/sp
299: * are needed only for :r and ?, and because ptrace() only reads an int
300: * at a time it requires many system calls to read the complete register set.
301: * Return 1 on success, 0 on failure.
302: */
303: int
304: get_regs(flag) int flag;
305: {
306: static char *nope = "Cannot read registers";
307:
308: dbprintf(("get_regs(%d) reg_flag=%d\n", flag, reg_flag));
309:
310: if (reg_flag != R_INVALID && reg_flag >= flag)
311: return 1; /* already read */
312: reg_flag = R_INVALID; /* in case read fails */
313: if (flag == R_SOME) {
314: add = PTRACE_EIP;
315: if (getb(USEG, (char *)&ureg.ur_ip, PTSIZE) == 0)
316: return printr(nope);
317: add = PTRACE_EBP;
318: if (getb(USEG, (char *)&ureg.ur_bp, PTSIZE) == 0)
319: return printr(nope);
320: add = PTRACE_UESP;
321: if (getb(USEG, (char *)&ureg.ur_sp, PTSIZE) == 0)
322: return printr(nope);
323: add = PTRACE_SIG;
324: if (getb(USEG, (char *)&ureg.ur_sig, PTSIZE) == 0)
325: return printr("Cannot read signal in traced process");
326: dbprintf(("get_regs(R_SOME): ip=%x bp=%x sp=%x sig=%d\n", ureg.ur_ip, ureg.ur_bp, ureg.ur_sp, ureg.ur_sig));
327: } else { /* R_GEN or R_ALL */
328: add = UREG_BASE; /* pseudo-offset of ureg */
329: if (getb(USEG, (char *)&ureg,
330: (flag==R_GEN) ? UREG_GEN_SIZE : UREG_ALL_SIZE) == 0)
331: return printr(nope);
332: }
333: reg_flag = flag;
334: return 1;
335: }
336:
337: /*
338: * Return the child program signal number.
339: */
340: int
341: get_sig()
342: {
343: return ureg.ur_sig;
344: }
345:
346: /*
347: * Get a word or dword from segment s and store it in *lp.
348: */
349: int
350: get_sized(s, lp) int s; ADDR_T *lp;
351: {
352: unsigned short i;
353:
354: if (IS_LOUT) {
355: if (getb(s, (char *)&i, sizeof(i)) == 0) /* get 2 bytes for l.out */
356: return 0;
357: *lp = (ADDR_T)i;
358: return 1;
359: }
360: return getb(s, (char *)lp, sizeof(*lp)); /* get 4 bytes for COFF */
361:
362: }
363:
364: /*
365: * Return the stack pointer.
366: * Mask to 16-bit value for l.out.
367: */
368: ADDR_T
369: get_sp()
370: {
371: return (IS_LOUT) ? ureg.ur_sp & 0xFFFF : ureg.ur_sp;
372: }
373:
374: /*
375: * Perform i386-specific initialization.
376: * This checks whether NDP (or emulation) is present;
377: * get_fp_reg requires either NDP or emulation
378: * to convert an 80-bit NDP double to 64-bit format.
379: */
380: void
381: init_mch()
382: {
383: int NDPstate;
384:
385: if (sysi86(SI86FPHW, &NDPstate) == -1)
386: panic("sysi86() call failed");
387: NDP_flag = (NDPstate != FP_NO);
388: }
389:
390: /*
391: * Return true if instruction at %eip is a call.
392: */
393: int
394: is_call()
395: {
396: unsigned char w[4];
397: int i;
398:
399: add = get_pc();
400: dbprintf(("is_call(): eip=%x\n", add));
401: if (getb(ISEG, (char *)&i, sizeof(i)) == 0)
402: return;
403: w[0] = i & 0xff;
404: w[1] = (i>>8) & 0xff;
405: return (w[0] == CALL) /* Direct call */
406: || (w[0]==ICALL1 && (w[1]&IC2MSK)==ICALL2); /* Indirect call */
407: }
408:
409: /*
410: * If the given name matches a register,
411: * set up 'sp' with the address of a register in the user area.
412: */
413: int
414: is_reg(sp) SYM *sp;
415: {
416: register char *cp, *np;
417: register REGNAME *rp;
418:
419: for (cp = sp->s_id, rp = reg_name; rp < ®_name[NREGS]; rp++) {
420: np = rp->r_name;
421: if (strcmp(cp, np) == 0) {
422: sp->s_addr = rp->r_offset;
423: sp->s_segn = USEG;
424: return 1;
425: } else if (*np == 'e' && strcmp(cp, np+1) == 0) {
426: /* Recognize e.g. "si" as word equivalent of "esi". */
427: sp->s_addr = rp->r_offset;
428: sp->s_segn = USEG;
429: return 1;
430: }
431: }
432: return 0;
433: }
434:
435: /*
436: * Watch out for system calls if single stepping.
437: * If at system call, save the address (sys_add) and the contents (sys_in)
438: * of the replaced instruction and set *flagp to 2.
439: * Return 0 on error.
440: */
441: int
442: is_syscall(flagp) int *flagp;
443: {
444: unsigned char w;
445:
446: if (*flagp == 0)
447: return 1; /* not single stepping */
448: add = get_pc();
449: dbprintf(("is_syscall(): pc=%X ", add));
450: if (getb(ISEG, (char *)&w, sizeof(w)) == 0)
451: return 1; /* should this be 0? */
452:
453: if (IS_LOUT) { /* l.out */
454: if (w != INT) /* Interrupt (system call) */
455: return 1; /* not at a system call */
456: add = get_pc() + 2;
457: } else { /* COFF */
458: if (w != LCALL) /* lcall (possibly system call) */
459: return 1; /* not at a system call */
460: add = get_pc() + 7;
461: }
462: sys_add = add;
463: if (getb(ISEG, (char *)sys_in, sizeof(sys_in)) == 0)
464: return printr("Cannot get breakpoint");
465: add = sys_add;
466: dbprintf(("is_syscall: set system call bpt at %X replacing %X\n", add, sys_in[0]));
467: if (putb(ISEG, (char *)bin, sizeof(bin)) == 0)
468: return printr("Cannot set breakpoint");
469: *flagp = 2; /* indicate system call seen */
470: return 1;
471: }
472:
473: /*
474: * Print an address as a constant.
475: */
476: void
477: print_const(buf, addr) register char *buf; ADDR_T addr;
478: {
479: sprintf(buf, (addr < (ADDR_T)0x10) ? "%ld" : "0x%lX", (long)addr);
480: }
481:
482: /*
483: * Restore after stepping past a system call.
484: * This basically undoes what is_syscall() does.
485: * Note that the system call may not return where you would expect,
486: * e.g. for sigreturn!
487: */
488: int
489: rest_syscall(flagp) int *flagp;
490: {
491: ADDR_T pc;
492:
493: pc = get_pc() - sizeof(BIN);
494: if (pc == sys_add)
495: set_pc(pc); /* back up %eip */
496: dbprintf(("rest_syscall(): step_flag=%d sys_add=%X pc=%X\n", *flagp, sys_add, pc));
497: add = sys_add; /* restore instruction */
498: if (putb(ISEG, (char *)sys_in, sizeof(sys_in)) == 0)
499: return printr("Cannot restore sys_in");
500: *flagp = 1; /* restore step_mode==1 */
501: return 1;
502: }
503:
504: /*
505: * Set up segmentation for COFF.
506: */
507: void
508: setcoffseg()
509: {
510: register SCNHDR *shp, *oshp;
511: ADDR_T fbase, tbase, tsize, dbase, dsize, bbase, bsize;
512: off_t tsp, dsp, bsp;
513: int i;
514:
515: fbase = sizeof(FILEHDR) + coff_hdr.f_opthdr;
516: tbase = tsize = dbase = dsize = bbase = bsize = MIN_ADDR;
517: tsp = dsp = bsp = (off_t)0;
518: oshp = shp = (SCNHDR *)nalloc(coff_hdr.f_nscns*sizeof(SCNHDR), "COFF section headers");
519: if (fseek(lfp, (long)fbase, SEEK_SET) == -1)
520: panic("COFF header seek failed");
521: for (i = 0; i < coff_hdr.f_nscns; shp++, i++) {
522: /* Read a COFF section header. */
523: if (fread(shp, sizeof(SCNHDR), 1, lfp) != 1)
524: panic("Cannot read COFF section header");
525:
526: /* Set base and size info according to flags. */
527: switch((int)shp->s_flags) {
528: case STYP_TEXT:
529: tbase = shp->s_vaddr;
530: tsize = shp->s_size;
531: tsp = shp->s_scnptr;
532: break;
533: case STYP_DATA:
534: dbase = shp->s_vaddr;
535: dsize = shp->s_size;
536: dsp = shp->s_scnptr;
537: break;
538: case STYP_BSS:
539: bbase = shp->s_vaddr;
540: bsize = shp->s_size;
541: bsp = shp->s_scnptr;
542: break;
543: default:
544: continue; /* ignore other section types */
545: }
546: }
547:
548: endpure = (MAP *)NULL; /* no pure data */
549: #if 0
550: dbase = rup(dbase); /* round up? */
551: #endif
552: #if 1
553: /* Assume separate. */
554: map_set(ISEG, tbase, tsize, tsp, MAP_PROG);
555: map_set(DSEG, dbase, dsize, dsp, MAP_PROG);
556: map_set(DSEG, bbase, bsize+4L, bsp, MAP_PROG);
557: #else
558: /* Assume NOT separate. */
559: map_set(DSEG, tbase, tsize, tsp, MAP_PROG);
560: map_set(DSEG, dbase, dsize, dsp, MAP_PROG);
561: map_set(DSEG, bbase, bsize+4L, bsp, MAP_PROG);
562: ISPACE = DSPACE;
563: #endif
564: nfree(oshp);
565: }
566:
567: /*
568: * Set up segmentation for a system dump.
569: */
570: void
571: setdump(name) char *name;
572: {
573: setkmem(name);
574: }
575:
576: /*
577: * Set up segmentation for kernel memory.
578: * FIX_ME This is much bogosity. "etext" is no more, for one thing...
579: */
580: void
581: setkmem(name) char *name;
582: {
583: register off_t l;
584: unsigned int n;
585: static SYM *etextp;
586:
587: cfn = name;
588: cfp = openfile(name, rflag);
589: map_set(USEG, MIN_ADDR, MAX_ADDR, (off_t)0, MAP_CORE);
590: add = 2;
591: if (getb(USEG, (char *)&n, sizeof(n)) == 0)
592: panic("Bad memory file");
593: l = (off_t)n << 4;
594: map_set(ISEG, MIN_ADDR, MAX_ADDR, (off_t)l, MAP_CORE);
595: if (etextp == (SYM *)NULL) {
596: /* Find the address of "etext". */
597: etextp = (SYM *)nalloc(sizeof(SYM) + 6, "symbol \"etext\"");
598: strcpy(etextp->s_id, "etext");
599: if (!is_symbol(etextp))
600: etextp->s_addr = (off_t)1;
601: dbprintf(("main=%lX\n", etextp->s_addr));
602: }
603: if (!is_symbol(etextp))
604: DSPACE = ISPACE;
605: else {
606: n = rup(etextp->s_addr);
607: map_set(DSEG, MIN_ADDR, MAX_ADDR, (off_t)l+n, MAP_CORE);
608: }
609: }
610:
611: /*
612: * Set up segmentation for an l.out.
613: */
614: void
615: setloutseg()
616: {
617: register off_t fbase;
618: register ADDR_T si, pi, bi, sd, pd, rs;
619:
620: fbase = (off_t)sizeof(ldh);
621: si = ldh.l_ssize[L_SHRI];
622: pi = ldh.l_ssize[L_PRVI];
623: bi = ldh.l_ssize[L_BSSI];
624: sd = ldh.l_ssize[L_SHRD];
625: pd = ldh.l_ssize[L_PRVD];
626: dbprintf(("l.out sizes: si=%lX pi=%lX bi=%lX sd=%lX pd=%lX\n", si, pi, bi, sd, pd));
627: endpure = (MAP *)NULL; /* no pure data */
628: switch (ldh.l_flag & (LF_SEP|LF_SHR)) {
629:
630: case 0: /* not separate, not shared */
631: map_set(DSEG, MIN_ADDR, si+pi, fbase, MAP_PROG);
632: map_set(DSEG, si+pi+bi, sd+pd, fbase+(off_t)(si+pi), MAP_PROG);
633: ISPACE = DSPACE;
634: break;
635:
636: case LF_SHR: /* not separate, shared */
637: rs = rup(si+sd);
638: map_set(DSEG, MIN_ADDR, si, fbase, MAP_PROG);
639: map_set(DSEG, si, sd, fbase+(off_t)(si+pi), MAP_PROG);
640: map_set(DSEG, rs, pi, fbase+(off_t)si, MAP_PROG);
641: map_set(DSEG, rs+pi, pd, fbase+(off_t)(si+pi+sd), MAP_PROG);
642: ISPACE = DSPACE;
643: break;
644:
645: case LF_SEP: /* separate, not shared */
646: map_set(ISEG, MIN_ADDR, si+pi, fbase, MAP_PROG);
647: map_set(DSEG, MIN_ADDR, sd+pd, fbase+(off_t)(si+pi), MAP_PROG);
648: break;
649:
650: case LF_SEP|LF_SHR: /* separate, shared */
651: rs = rup(sd);
652: map_set(ISEG, MIN_ADDR, si+pi, fbase, MAP_PROG);
653: map_set(DSEG, MIN_ADDR, sd, fbase+(off_t)(si+pi), MAP_PROG);
654: map_set(DSEG, rs, pd, fbase+(off_t)(si+pi+sd), MAP_PROG);
655: break;
656: }
657: }
658:
659: /*
660: * Set the program counter.
661: */
662: void
663: set_pc(ip) ADDR_T ip;
664: {
665: dbprintf(("set_pc(%lX)\n", ip));
666: ureg.ur_ip = ip;
667: add = PTRACE_EIP;
668: putb(USEG, (char *)&ureg.ur_ip, sizeof(ureg.ur_ip));
669: }
670:
671: /*
672: * Set a BSIN breakpoint at the return address given by %esp.
673: */
674: void
675: set_ra_bpt()
676: {
677: ADDR_T ra;
678:
679: add = get_sp();
680: dbprintf(("set_ra_bpt(): sp=%lX ", add));
681: if (get_sized(DSEG, &ra) == 0)
682: return;
683: bpt_set(BSIN, ra, get_fp(), NULL);
684: dbprintf(("ra=%lX bp=%lX\n", ra, get_fp()));
685: }
686:
687: /*
688: * Set the signal number.
689: * This gets executed when a core file is read;
690: * dunno why the signal number in the register save is different.
691: */
692: void
693: set_sig(sig) int sig;
694: {
695: dbprintf(("set_sig(%X)\n", sig));
696: ureg.ur_sig = sig;
697: add = PTRACE_SIG;
698: putb(USEG, (char *)&ureg.ur_sig, sizeof(ureg.ur_sig));
699: }
700:
701: /*
702: * Stack traceback.
703: * This code knows some gory details about the C calling sequence
704: * for code compiled by either the i8086 compiler or the i386 compiler.
705: * It must be changed if the calling sequence changes!
706: *
707: * i8086 stack frame:
708: * bp+6+(2*n)-> [argn]
709: * [...]
710: * bp+8-> [arg1]
711: * bp+6-> ra
712: * bp+4-> saved si
713: * bp+2-> saved di
714: * bp-> saved bp
715: * bp-n [locals]
716: * Here [] indicates optional; note that the registers are always saved.
717: * Arguments are popped after the call with "add %sp, $n".
718: *
719: * i386 stack frame:
720: * bp+4+(4*n)-> [argn]
721: * [...]
722: * bp+8-> [arg1]
723: * bp+4-> ra
724: * bp-> saved bp
725: * bp-x-> [locals]
726: * bp-x-4-> [saved esi]
727: * bp-x-8-> [saved edi]
728: * bp-x-12-> [saved ebx]
729: * Here the registers are saved only if required.
730: * The function entry sequence may begin with either "enter $n, $0" (if locals)
731: * or with "push %ebp; movl %ebp, %esp" (if no locals).
732: * Arguments are popped after the call with "pop %ecx" or "add %esp, $n".
733: */
734: void
735: traceback(levels) int levels;
736: {
737: ADDR_T bp, pc, rpc; /* ebp, eip, return pc */
738: register int argc; /* arg count */
739: int at_start; /* at start, before ebp save */
740: int qflag; /* quit flag */
741: static SYM *mainp; /* "main" */
742: int size; /* bytes per stack item */
743: SYM *sp;
744: int i, n;
745: char *fmt;
746: unsigned char b[3], e[1]; /* opcode buffers */
747:
748: fmt = (IS_LOUT) ? ADDR16_FMT : ADDR_FMT;
749: if (mainp == (SYM *)NULL) {
750: /* Find the address of "main". */
751: mainp = (SYM *)nalloc(sizeof(SYM) + 5, "symbol \"main\"");
752: strcpy(mainp->s_id, "main");
753: if (!is_symbol(mainp))
754: mainp->s_addr = (off_t)1;
755: dbprintf(("main=%lX\n", mainp->s_addr));
756: }
757:
758: /* Set operand size, get registers ip and bp. */
759: size = (IS_LOUT) ? 2 : 4; /* word for l.out, dword for COFF */
760: add = pc = get_pc();
761: dbprintf(("ip=%lX\n", pc));
762: if (getb(ISEG, b, 1) == 0) { /* fetch opcode at ip to b[] */
763: printe("Illegal ip");
764: return;
765: }
766: bp = get_fp();
767: dbprintf(("bp=%lX\n", bp));
768:
769: /* Fetch the first byte of the current routine. */
770: if ((sp = findsym(1, pc)) != (SYM *)NULL) {
771: dbprintf(("findsym found %s, addr=%lX\n", sp->s_id, sp->s_addr));
772: add = sp->s_addr;
773: getb(ISEG, (char *)e, 1);
774: dbprintf(("opcode fetched from %s: %x\n", sp->s_id, e[0]));
775: } else
776: e[0] = (IS_LOUT) ? PUSHESI : ENTER; /* take a guess... */
777:
778: /*
779: * If we are right at the start of the routine,
780: * set at_start and kludge bp so that we can see this
781: * call in the traceback.
782: * sp currently must point to ra,
783: * so bp will be at sp-6 for l.out or sp-4 for COFF.
784: * Otherwise, use the current bp as is.
785: */
786: if ((IS_LOUT && (b[0]==PUSHESI || e[0]!=PUSHESI))
787: || (!IS_LOUT && (b[0]==ENTER || b[0]==PUSHEBP || (e[0]!=ENTER && e[0]!=PUSHEBP)))) {
788: at_start = 1;
789: bp = ureg.ur_sp - (8 - size);
790: if (IS_LOUT)
791: bp &= 0xFFFF;
792: } else
793: at_start = 0;
794:
795: for (qflag = 0; ; ) {
796:
797: /* Fetch the return PC. */
798: add = (IS_LOUT) ? bp + 6 : bp + 4;
799: if (get_sized(DSEG, &rpc) == 0)
800: break;
801: dbprintf(("return pc=%lX\n", rpc));
802:
803: /*
804: * Fetch code from return location and look for stack adjust.
805: * If present, calculate the argc from it.
806: * The i386 compiler deletes stack adjust before "leave";
807: * these are currently printed with "(???)" args (argc==-1).
808: */
809: argc = 0;
810: add = rpc;
811: if (getb(ISEG, b, 3) != 0) {
812: if (b[0]==ADDSP1 && b[1]==ADDSP2) /* add sp,$? */
813: argc = b[2] / size;
814: else if (!IS_LOUT && b[0]==POPECX) /* pop %ecx */
815: argc = 1;
816: else if (!IS_LOUT && b[0]==LEAVE) /* leave */
817: argc = -1;
818: }
819: dbprintf(("argc=%d\n", argc));
820:
821: /*
822: * Fetch the opcode preceding the return PC, presumably "call".
823: * Print a line like "bp pc name(arg1, ..., argn)\n".
824: */
825: add = rpc - 1 - size;
826: if (getb(ISEG, b, 1) == 0)
827: break;
828: if (get_sized(ISEG, &n) == 0)
829: break;
830: printx(fmt, bp);
831: printx(" ");
832: printx(fmt, pc);
833: printx(" ");
834: if (b[0] == CALL) {
835: n += rpc;
836: putaddr(ISEG, (ADDR_T)n);
837: if (n == mainp->s_addr) {
838: qflag = 1;
839: argc = 3;
840: }
841: } else {
842: /* Not a call, e.g. icall. */
843: if ((sp = findsym(1, pc)) == (SYM *)NULL)
844: printx("*");
845: else {
846: putaddr(ISEG, pc);
847: if (strcmp(sp->s_id, "main") == 0) {
848: qflag = 1;
849: argc = 3;
850: }
851: }
852: }
853:
854: /*
855: * Splat the arg list.
856: * Offset 8 coincidently works for both file formats.
857: */
858: putx('(');
859: add = bp + 8;
860: if (argc == -1)
861: printx("???");
862: else for (i = 0; i < argc; i++) {
863: if (get_sized(DSEG, &n) == 0)
864: break;
865: if (i != 0)
866: printx(", ");
867: print_const(miscbuf, (ADDR_T)n);
868: printx("%s", miscbuf);
869: }
870: printx(")\n");
871:
872: /* Move to the next frame and repeat ad nauseum. */
873: if (testint())
874: return;
875: if (qflag)
876: break;
877: if (at_start) {
878: at_start = 0;
879: bp = get_fp();
880: } else {
881: add = bp;
882: if (get_sized(DSEG, &bp) == 0)
883: break;
884: }
885: if (--levels == 0)
886: return;
887: pc = rpc;
888: }
889: }
890:
891: /* end of db/i386/i386db1.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.