![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to opset.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / adb.vax|
Return to opset.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / adb.vax |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)opset.c 4.8 (Berkeley) 1/16/89";
3: #endif
4:
5: /*
6: * adb - instruction printing routines: VAX version
7: */
8:
9: #include "defs.h"
10:
11: /*
12: * Get assembler definitions; declare tables that appear in optab.c.
13: */
14: #define ADB
15: #undef INSTTAB
16: #include "instrs.h"
17:
18: extern struct insttab insttab[];
19: extern char *regname[];
20: extern char *fltimm[];
21:
22: /* these are shared with the assembler: */
23: extern int ty_NORELOC[];
24: extern int ty_nbyte[];
25: #ifdef notyet
26: extern int ty_float[]; /* must update assizetab.c */
27: #endif
28:
29: /*
30: * Definitions for registers and for operand classes.
31: */
32: #define R_PC 0xF
33:
34: #define OC_IMM0 0x0 /* literal, aka immediate */
35: #define OC_IMM1 0x1
36: #define OC_IMM2 0x2
37: #define OC_IMM3 0x3
38: #define OC_INDEX 0x4 /* [rN] */
39: #define OC_REG 0x5 /* rN */
40: #define OC_DREG 0x6 /* (rN) */
41: #define OC_ADREG 0x7 /* -(rN) */
42: #define OC_AIREG 0x8 /* (rN)+ */
43: #define OC_DAIREG 0x9 /* *(rN)+ */
44: #define OC_BDISP 0xA /* b(rN) */
45: #define OC_DBDISP 0xB /* *b(rN) */
46: #define OC_WDISP 0xC /* w(rN) */
47: #define OC_DWDISP 0xD /* *w(rN) */
48: #define OC_LDISP 0xE /* l(rN) */
49: #define OC_DLDISP 0xF /* *l(rN) */
50:
51: #define OC_SHIFT 4
52: #define OC_CONS(oc,reg) (((oc & 0xF) << OC_SHIFT) | (reg & 0xF))
53: #define OC_AMEXT(x) (((x) >> OC_SHIFT) & 0xF)
54: #define OC_REGEXT(x) ((x) & 0xF)
55:
56: /*
57: * Definitions for special instructions.
58: */
59: #define CASEB 0x8F
60: #define CASEW 0xAF
61: #define CASEL 0xCF
62: #define CHMK 0xBC
63:
64: /*
65: * ioptab is a two level 1-based index by opcode into insttab.
66: * The first level into ioptab is given by mapescbyte().
67: * Since ioptab is 1-based, references would be expected to
68: * be of the form
69: *
70: * ptr = &insttab[ioptab[a][b] - 1];
71: *
72: * but the form
73: *
74: * ptr = &(insttab - 1)[ioptab[a][b]]
75: *
76: * is equivalent and generates less code (!) (time to work on the
77: * compiler again...).
78: */
79: static short ioptab[3][256];
80: #define mapescbyte(b) ((b) == ESCD ? 1 : (b) == ESCF ? 2 : 0)
81:
82: mkioptab()
83: {
84: register struct insttab *p;
85: register int mapchar;
86: register short *iop;
87:
88: /*
89: * The idea here is that whenever two opcodes have the same
90: * codes, but different mnemonics, we want to prefer the one
91: * with the `simpler' type. Here lower numbers make simpler
92: * types. This seems (likely) to work reasonably well.
93: *
94: * At present, this affects the following opcodes:
95: *
96: * 7c clrq | clrd | clrg
97: * 7e movaq | movad | movag
98: * 7f pushaq | pushad | pushag
99: * d4 clrl | clrf
100: * de moval | movaf
101: * df pushal | pushaf
102: *
103: * In each case, the leftmost mnemonics are preferred.
104: */
105: #define PREFER(a, b) (A_TYPEXT((a)->argtype[0]) < A_TYPEXT((b)->argtype[0]))
106:
107: for (p = insttab; p->iname != NULL; p++) {
108: mapchar = mapescbyte(p->eopcode);
109: iop = &ioptab[mapchar][p->popcode];
110: if (*iop == 0 || PREFER(p, &(insttab - 1)[*iop]))
111: *iop = p - (insttab - 1);
112: }
113: #undef PREFER
114: }
115:
116: /*
117: * Global variables for communication between the minions and printins.
118: */
119: static int idsp; /* which space we are in (INSTR or DATA) */
120: static int argno; /* which argument we are working on */
121: static int dotoff; /* offset from dot for this arg */
122: static int vset[7]; /* set by savevar, cleared by clrvar */
123:
124: #define savevar(v) (vset[argno] = 1, var[argno] = v)
125: #define clrvar(v) (vset[argno] = 0, var[argno] = 0x80000000)
126:
127: /*
128: * Read some bytes, checking for errors, and updating the offset.
129: */
130: #define getsomebytes(ptr, nbytes) \
131: (void) adbread(idsp, inkdot(dotoff), ptr, nbytes); \
132: checkerr(); \
133: dotoff += (nbytes)
134:
135: /*
136: * Read one byte, and advance the offset.
137: */
138: static int
139: getbyte()
140: {
141: u_char c;
142:
143: getsomebytes(&c, sizeof(c));
144: return (c);
145: }
146:
147: /*
148: * adb's view: printins() prints one instruction, and sets dotinc.
149: */
150: printins(space)
151: int space;
152: {
153: register u_char *ap;
154: register struct insttab *ip;
155: int ins, mode, optype, mapchar, t;
156: char *lastix, *ixreg;
157: char *operandout();
158:
159: /*
160: * Set up the module variables, pick up the instruction, and
161: * find its table entry.
162: */
163: idsp = space;
164: dotoff = 0;
165: ins = idsp == SP_NONE ? (u_char)dot : getbyte();
166: if ((mapchar = mapescbyte(ins)) != 0) {
167: t = getbyte();
168: if (ioptab[mapchar][t] == 0) {
169: /*
170: * Oops; not a defined instruction; back over this
171: * escape byte.
172: */
173: dotoff--;
174: mapchar = 0;
175: } else
176: ins = t;
177: }
178: if ((t = ioptab[mapchar][ins]) == 0) {
179: adbprintf("<undefined operator byte>: %x", ins);
180: dotinc = 1;
181: return;
182: }
183: ip = &(insttab - 1)[t];
184: adbprintf("%s%8t", ip->iname);
185:
186: /*
187: * For each argument, decode that argument.
188: * We set t if we notice something fishy.
189: */
190: t = 0;
191: for (ap = ip->argtype, argno = 0; argno < ip->nargs; argno++) {
192: optype = *ap++;
193: clrvar();
194: if (argno != 0)
195: printc(',');
196: /*
197: * lastix and ixreg track the register indexed addressing
198: * mode, which is written as <stuff>[reg] but encoded as
199: * [reg]<stuff>. Only one [reg] is legal.
200: */
201: lastix = NULL;
202: do {
203: /* check for special pc-relative (branch) */
204: if (A_ACCEXT(optype) & ACCB) {
205: switch (A_TYPEXT(optype)) {
206: case TYPB:
207: mode = OC_CONS(OC_BDISP, R_PC);
208: break;
209: case TYPW:
210: mode = OC_CONS(OC_WDISP, R_PC);
211: break;
212: }
213: } else
214: mode = getbyte();
215: ixreg = operandout(mode, optype, ins == CHMK);
216: if (lastix) {
217: adbprintf("[%s]", lastix);
218: if (ixreg)
219: t = 1;
220: }
221: } while ((lastix = ixreg) != NULL);
222: }
223: if (t)
224: adbprintf("%4t# not code? illegal arguments detected ");
225: switch (ins) {
226: case CASEB:
227: case CASEW:
228: case CASEL:
229: if (mapchar == 0 && vset[1] && vset[2])
230: casebody(var[1], var[2]);
231: else
232: adbprintf("\n%4t# not code? non-constant cases ");
233: }
234: dotinc = dotoff;
235: }
236:
237: /*
238: * Print out the locations to which each of the cases branch.
239: * This routine carefully allows expressions such as
240: *
241: * casel <val>,$<const>,$0x7fffffff
242: *
243: * even though they do not fit on a VAX.
244: */
245: static
246: casebody(base, limit)
247: register expr_t base, limit;
248: {
249: register expr_t i = -1;
250: register addr_t a, baseaddr = inkdot(dotoff);
251: short displ;
252:
253: argno = 0;
254: do {
255: i++;
256: adbprintf("\n %R: ", base++);
257: getsomebytes(&displ, sizeof(displ));
258: a = displ + baseaddr;
259: psymoff("%R", a, SP_DATA, maxoff, "");
260: savevar(a);
261: } while (i != limit);
262: }
263:
264: /*
265: * Handle a normal operand. Return pointer to register
266: * name if this is an index instruction, else return NULL.
267: */
268: static char *
269: operandout(mode, optype, ischmk)
270: register int mode;
271: int optype, ischmk;
272: {
273: register char *r;
274: register int regnumber, nbytes, n;
275: union {
276: char b;
277: short w;
278: int l;
279: } displ;
280: extern char *syscalls[];
281: extern int nsys;
282:
283: regnumber = OC_REGEXT(mode);
284: r = regname[regnumber];
285: switch (OC_AMEXT(mode)) {
286:
287: case OC_IMM0: case OC_IMM1:
288: case OC_IMM2: case OC_IMM3:
289: savevar(mode);
290: printc('$');
291: #ifdef notyet
292: if (ty_float[A_TYPEXT(optype)])
293: prints(fltimm[mode]);
294: else if (ischmk && (u_int)mode < nsys && syscalls[mode])
295: prints(syscalls[mode]);
296: else
297: adbprintf("%V", mode);
298: #else
299: switch (A_TYPEXT(optype)) {
300:
301: case TYPF:
302: case TYPD:
303: case TYPG:
304: case TYPH:
305: prints(fltimm[mode]);
306: break;
307:
308: default:
309: if (ischmk && (u_int)mode < nsys && syscalls[mode])
310: prints(syscalls[mode]);
311: else
312: adbprintf("%V", mode);
313: break;
314: }
315: #endif
316: return (0);
317:
318: case OC_INDEX:
319: return (r); /* will be printed later */
320:
321: case OC_REG:
322: adbprintf("%s", r);
323: return (0);
324:
325: case OC_DREG:
326: adbprintf("(%s)", r);
327: return (0);
328:
329: case OC_ADREG:
330: adbprintf("-(%s)", r);
331: return (0);
332:
333: case OC_DAIREG:
334: printc('*');
335: /* FALLTHROUGH */
336:
337: case OC_AIREG:
338: if (regnumber != R_PC) {
339: adbprintf("(%s)+", r);
340: return (0);
341: }
342: /* PC immediate */
343: printc('$');
344: if (mode == OC_CONS(OC_DAIREG, R_PC))
345: /* PC absolute, always 4 bytes */
346: nbytes = 4;
347: else {
348: nbytes = ty_nbyte[A_TYPEXT(optype)];
349: if (ty_NORELOC[A_TYPEXT(optype)]) {
350: bignumprint(nbytes, optype);
351: return (0);
352: }
353: }
354: break;
355:
356: case OC_DBDISP:
357: printc('*');
358: /* FALLTHROUGH */
359:
360: case OC_BDISP:
361: nbytes = 1;
362: break;
363:
364: case OC_DWDISP:
365: printc('*');
366: /* FALLTHROUGH */
367:
368: case OC_WDISP:
369: nbytes = 2;
370: break;
371:
372: case OC_DLDISP:
373: printc('*');
374: /* FALLTHROUGH */
375:
376: case OC_LDISP:
377: nbytes = 4;
378: break;
379:
380: default:
381: panic("operandout 1");
382: /* NOTREACHED */
383: }
384:
385: /*
386: * Print a displacement format.
387: */
388: getsomebytes(&displ, nbytes);
389: switch (nbytes) {
390: case 1:
391: n = displ.b;
392: break;
393: case 2:
394: n = displ.w;
395: break;
396: case 4:
397: n = displ.l;
398: break;
399: default:
400: panic("operandout 2");
401: /* NOTREACHED */
402: }
403: if (regnumber == R_PC) {
404: switch (OC_AMEXT(mode)) {
405:
406: case OC_DAIREG:
407: if (ischmk && (u_int)n < nsys && syscalls[n]) {
408: prints(syscalls[n]);
409: return (0);
410: }
411: break;
412:
413: case OC_BDISP: case OC_DBDISP:
414: case OC_WDISP: case OC_DWDISP:
415: case OC_LDISP: case OC_DLDISP:
416: /* PC offset */
417: n += dot + dotoff;
418: }
419: psymoff("%V", (addr_t)n, SP_DATA, maxoff, "");
420: } else
421: adbprintf("%V(%s)", (expr_t)n, regname[regnumber]);
422: savevar(n);
423: return (0);
424: }
425:
426: /*
427: * Print an F-float, D-float, G-float, H-float, quadword, or octaword.
428: * F- and D-floating values are printed as themselves, unless they are
429: * reserved operand bit patterns; these, and the others, are printed
430: * instead in hex, with leading zeroes suppressed.
431: */
432: static
433: bignumprint(nbytes, optype)
434: int nbytes, optype;
435: {
436: register char *p;
437: register int i;
438: union {
439: float f; /* if f-floating */
440: double d; /* if d-floating */
441: u_char c[16]; /* if G, H, Q, or O */
442: } n;
443: char expbuf[4*8+1]; /* max 4 8-character hex ints */
444: static char tohex[] = "0123456789abcdef";
445:
446: /*
447: * Read in the number, then figure out how to print it.
448: */
449: getsomebytes(&n, nbytes);
450: switch (A_TYPEXT(optype)) {
451:
452: case TYPF:
453: if ((p = checkfloat((caddr_t)&n.f, 0)) == NULL) {
454: adbprintf("0f%f", n.f);
455: return;
456: }
457: adbprintf("%s 0f::", p);
458: break;
459:
460: case TYPD:
461: if ((p = checkfloat((caddr_t)&n.d, 1)) == NULL) {
462: adbprintf("0d%f", n.d);
463: return;
464: }
465: adbprintf("%s 0d::", p);
466: break;
467:
468: case TYPG:
469: adbprintf("0g::");
470: break;
471:
472: case TYPH:
473: adbprintf("0h::");
474: break;
475:
476: case TYPQ:
477: case TYPO:
478: break;
479:
480: default:
481: panic("bignumprint");
482: }
483:
484: /*
485: * Expand the number into expbuf, then skip leading zeroes.
486: * Be careful not to skip the entire number.
487: */
488: for (p = expbuf, i = nbytes; --i >= 0;) {
489: *p++ = tohex[n.c[i] >> 4];
490: *p++ = tohex[n.c[i] & 15];
491: }
492: for (p = expbuf; *p == '0'; p++)
493: /* void */;
494: prints(*p ? p : p - 1);
495: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.