![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kdb_opset.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax|
Return to kdb_opset.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vax |
1.1 root 1: /*
2: * @(#)kdb_opset.c 7.3 (Berkeley) 5/26/88
3: */
4:
5: #include "../kdb/defs.h"
6:
7: /*
8: * Instruction printing.
9: */
10: REGLIST reglist [] = {
11: "p1lr", &pcb.pcb_p1lr, "p1br", (int *)&pcb.pcb_p1br,
12: "p0lr", &pcb.pcb_p0lr, "p0br", (int *)&pcb.pcb_p0br,
13: "ksp", &pcb.pcb_ksp, "esp", &pcb.pcb_esp,
14: "ssp", &pcb.pcb_ssp, "psl", &pcb.pcb_psl,
15: "pc", &pcb.pcb_pc, "usp", &pcb.pcb_usp,
16: "fp", &pcb.pcb_fp, "ap", &pcb.pcb_ap,
17: "r11", &pcb.pcb_r11, "r10", &pcb.pcb_r10,
18: "r9", &pcb.pcb_r9, "r8", &pcb.pcb_r8,
19: "r7", &pcb.pcb_r7, "r6", &pcb.pcb_r6,
20: "r5", &pcb.pcb_r5, "r4", &pcb.pcb_r4,
21: "r3", &pcb.pcb_r3, "r2", &pcb.pcb_r2,
22: "r1", &pcb.pcb_r1, "r0", &pcb.pcb_r0,
23: };
24:
25: /*
26: * Argument data types
27: *
28: * If you change these definitions, you must also change the tables
29: * in assizetab.c
30: */
31: #define TYPB 000 /* byte integer */
32: #define TYPW 001 /* word integer */
33: #define TYPL 002 /* long integer */
34: #define TYPQ 003 /* quad integer */
35: #define TYPO 004 /* octa integer */
36: #define TYPF 005 /* F float */
37: #define TYPD 006 /* D float */
38: #define TYPG 007 /* G float */
39: #define TYPH 010 /* H float */
40: #define TYPUNPACKED 011 /* when unpacked into mantissa & exponent */
41: #define TYPNONE 012 /* when nothing */
42: #define TYPLG 4 /* number of bits the above take up */
43:
44: #define TYPMASK ((1<<TYPLG)-1) /* the mask (assumes 2's comp arith) */
45: /*
46: * Constructors and extractors for argument access kinds and types
47: */
48: #define A_CONS(access, type) ((access) | (type))
49: #define A_ACCEXT(consed) ((consed) & (TYPMASK << TYPLG))
50: #define A_TYPEXT(consed) ((consed) & TYPMASK)
51:
52: /*
53: * Argument access types used to test validity of operands to operators
54: */
55: #define ACCR (1<<TYPLG) /* read */
56: #define ACCW (2<<TYPLG) /* write */
57: #define ACCB (4<<TYPLG) /* branch displacement */
58: #define ACCA (8<<TYPLG) /* address only */
59: #define ACCV (8<<TYPLG) /* address only */
60: #define ACCM (ACCR | ACCW) /* modify */
61: #define ACCI (ACCB | ACCR) /* XFC code */
62:
63: #define ACCESSMASK (ACCA | ACCR | ACCW | ACCB) /* the mask */
64:
65: /*
66: * Construction of TYPX and ACCX, to make the instrs table
67: * easy to use and read.
68: */
69: /*
70: * For real memory address
71: */
72: #define A_AB A_CONS(ACCA, TYPB)
73: #define A_AW A_CONS(ACCA, TYPW)
74: #define A_AL A_CONS(ACCA, TYPL)
75: #define A_AQ A_CONS(ACCA, TYPQ)
76: #define A_AO A_CONS(ACCA, TYPO)
77: #define A_AF A_CONS(ACCA, TYPF)
78: #define A_AD A_CONS(ACCA, TYPD)
79: #define A_AG A_CONS(ACCA, TYPG)
80: #define A_AH A_CONS(ACCA, TYPH)
81: /*
82: * For real memory addresses, or register addresses [sic]
83: *
84: * CHEAT! we just call these read access, since
85: * registers are allowed. All field instruction, except insv,
86: * are are read access fields.
87: */
88: #define A_VB A_CONS(ACCR, TYPB)
89: #define A_VW A_CONS(ACCR, TYPW)
90: #define A_VL A_CONS(ACCR, TYPL)
91: #define A_VQ A_CONS(ACCR, TYPQ)
92: #define A_VO A_CONS(ACCR, TYPO)
93: #define A_VF A_CONS(ACCR, TYPF)
94: #define A_VD A_CONS(ACCR, TYPD)
95: #define A_VG A_CONS(ACCR, TYPG)
96: #define A_VH A_CONS(ACCR, TYPH)
97: /*
98: * For branch displacement
99: */
100: #define A_BB A_CONS(ACCB, TYPB)
101: #define A_BW A_CONS(ACCB, TYPW)
102: /*
103: * For modification
104: */
105: #define A_MB A_CONS(ACCM, TYPB)
106: #define A_MW A_CONS(ACCM, TYPW)
107: #define A_ML A_CONS(ACCM, TYPL)
108: #define A_MF A_CONS(ACCM, TYPF)
109: #define A_MD A_CONS(ACCM, TYPD)
110: #define A_MG A_CONS(ACCM, TYPG)
111: #define A_MH A_CONS(ACCM, TYPH)
112: /*
113: * For reading
114: */
115: #define A_RB A_CONS(ACCR, TYPB)
116: #define A_RW A_CONS(ACCR, TYPW)
117: #define A_RL A_CONS(ACCR, TYPL)
118: #define A_RQ A_CONS(ACCR, TYPQ)
119: #define A_RO A_CONS(ACCR, TYPO)
120: #define A_RF A_CONS(ACCR, TYPF)
121: #define A_RD A_CONS(ACCR, TYPD)
122: #define A_RG A_CONS(ACCR, TYPG)
123: #define A_RH A_CONS(ACCR, TYPH)
124: /*
125: * For writing
126: */
127: #define A_WB A_CONS(ACCW, TYPB)
128: #define A_WW A_CONS(ACCW, TYPW)
129: #define A_WL A_CONS(ACCW, TYPL)
130: #define A_WQ A_CONS(ACCW, TYPQ)
131: #define A_WO A_CONS(ACCW, TYPO)
132: #define A_WF A_CONS(ACCW, TYPF)
133: #define A_WD A_CONS(ACCW, TYPD)
134: #define A_WG A_CONS(ACCW, TYPG)
135: #define A_WH A_CONS(ACCW, TYPH)
136:
137: struct insttab {
138: char *iname;
139: u_char eopcode;
140: u_char popcode;
141: char nargs;
142: u_char argtype[6];
143: };
144:
145: #define OP(name,eopcode,popdcode,nargs,a1,a2,a3,a4,a5,a6) \
146: {name,eopcode,popdcode,nargs,a1,a2,a3,a4,a5,a6}
147: /*
148: * Definitions for the escape bytes
149: */
150: #define CORE 0
151: #define NEW 1
152: #define ESCD 0xfd
153: #define ESCF 0xff
154: #define mapescbyte(b) ((b) == ESCD ? 1 : (b) == ESCF ? 2 : 0)
155:
156: static struct insttab insttab[] = {
157: #include "../vax/kdb_instrs"
158: 0};
159:
160: /*
161: * Convert TYP[BWLQOFDGH] into {1 if relocation not OK}
162: */
163: int ty_NORELOC[] = {
164: 0, /* TYPB */
165: 0, /* TYPW */
166: 0, /* TYPL */
167: 1, /* TYPQ */
168: 1, /* TYPO */
169: 1, /* TYPF */
170: 1, /* TYPD */
171: 1, /* TYPG */
172: 1, /* TYPH */
173: 1 /* TYPNONE */
174: };
175:
176: /*
177: * Convert TYP[BWLQOFDGH] into {1 ... 16}
178: */
179: int ty_nbyte[] = {
180: 1, /* TYPB */
181: 2, /* TYPW */
182: 4, /* TYPL */
183: 8, /* TYPQ */
184: 16, /* TYPO */
185: 4, /* TYPF */
186: 8, /* TYPD */
187: 8, /* TYPG */
188: 16, /* TYPH */
189: 0 /* TYPNONE */
190: };
191:
192: static char *regname[] = {
193: "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
194: "r8", "r9", "r10","r11","ap", "fp", "sp", "pc"
195: };
196: static char *fltimm[] = {
197: "0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875", "0.9375",
198: "1.0", "1.125", "1.25", "1.375", "1.5", "1.625", "1.75", "1.875",
199: "2.0", "2.25", "2.5", "2.75", "3.0", "3.25", "3.5", "3.75",
200: "4.0", "4.5", "5.0", "5.5", "6.0", "6.5", "7.0", "7.5",
201: "8.0", "9.0", "10.0", "11.0", "12.0", "13.0", "14.0", "15.0",
202: "16.0", "18.0", "20.0", "22.0", "24.0", "26.0", "28.0", "30.0",
203: "32.0", "36.0", "40.0", "44.0", "48.0", "52.0", "56.0", "60.0",
204: "64.0", "72.0", "80.0", "88.0", "96.0", "104.0", "112.0", "120.0"
205: };
206:
207: static int type, space, incp;
208: static long insoutvar[36];
209: /*
210: * Definitions for registers and for operand classes
211: */
212: static char *insregname(); /* how to print a register */
213:
214: #define R_PC 0xF
215:
216: #define OC_IMM0 0x0
217: #define OC_IMM1 0x1
218: #define OC_IMM2 0x2
219: #define OC_IMM3 0x3
220: #define OC_INDEX 0x4
221: #define OC_REG 0x5
222: #define OC_DREG 0x6
223: #define OC_ADREG 0x7
224: #define OC_AIREG 0x8
225: #define OC_DAIREG 0x9
226:
227: #define OC_BDISP 0xA
228: #define OC_DBDISP 0xB
229: #define OC_WDISP 0xC
230: #define OC_DWDISP 0xD
231: #define OC_LDISP 0xE
232: #define OC_DLDISP 0xF
233:
234: #define OC_SHIFT 4
235: #define OC_CONS(oc,reg) (((oc & 0xF) << OC_SHIFT) | (reg & 0xF))
236: #define OC_AMEXT(x) (((x) >> OC_SHIFT) & 0xF)
237: #define OC_REGEXT(x) ((x) & 0xF)
238:
239: /*
240: * Definitions for large numbers
241: */
242: #include "asnumber.h"
243: typedef struct as_number *numberp;
244: static numberp snarf();
245: static numberp snarfreloc();
246: /*
247: * Definitions for special instructions
248: */
249: #define CASEB 0x8F
250: #define CASEW 0xAF
251: #define CASEL 0xCF
252:
253: /* two level 1-based index by opcode into insttab */
254: static short ioptab[3][256];
255:
256: kdbsetup()
257: {
258: register struct insttab *p;
259: int mapchar;
260:
261: for(p = insttab; p->iname; p++){
262: mapchar = mapescbyte(p->eopcode);
263: if (ioptab[mapchar][p->popcode])
264: continue;
265: ioptab[mapchar][p->popcode] = (p - insttab) + 1;
266: }
267: }
268:
269: static u_char snarfuchar();
270: /*
271: * Global variables for communicating with the minions and printins
272: */
273: static int idsp;
274: static short argno; /* which argument one is working on */
275: static char insoutfmt[2]; /* how to format the relocated symbols */
276:
277: static savevar(val)
278: long val;
279: {
280: var[argno] = val;
281: insoutvar[argno] = val;
282: }
283:
284: /* ARGSUSED */
285: printins(fmt, Idsp, ins)
286: char fmt;
287: u_char ins;
288: int Idsp;
289: {
290: u_char mode; /* mode */
291: u_char ins2;
292: char *indexreg; /* print of which register indexes */
293: char *indexed; /* we indexed */
294: char *operandout();
295: register u_char *ap;
296: register struct insttab *ip;
297: u_char optype;
298: int mapchar;
299:
300: idsp = Idsp;
301: type = DSYM;
302: space = idsp;
303: insoutfmt[0] = 0;
304:
305: incp = 1;
306: if ((mapchar = mapescbyte(ins)) != 0){
307: ins2 = snarfuchar();
308: if (ioptab[mapchar][ins2] == 0){
309: /*
310: * Oops; not a defined instruction;
311: * back over this escape byte.
312: */
313: incp -= 1;
314: mapchar = 0;
315: } else {
316: ins = ins2;
317: }
318: }
319: if (ioptab[mapchar][ins] == 0){
320: printf("<undefined operator byte>: %x", ins);
321: goto ret;
322: }
323: ip = &insttab[ioptab[mapchar][ins] - 1];
324: printf("%s\t", ip->iname);
325:
326: for (ap = ip->argtype, argno = 0; argno < ip->nargs; argno++, ap++) {
327: savevar(0x80000000); /* an illegal symbol */
328: optype = *ap;
329: if (argno != 0)
330: printc(',');
331: indexreg = 0;
332: indexed = 0;
333: do{
334: if (A_ACCEXT(optype) & ACCB){
335: switch(A_TYPEXT(optype)){
336: case TYPB:
337: mode = OC_CONS(OC_BDISP, R_PC);
338: break;
339: case TYPW:
340: mode = OC_CONS(OC_WDISP, R_PC);
341: break;
342: }
343: } else {
344: mode = snarfuchar();
345: }
346: indexreg = operandout(mode, optype);
347: if (indexed)
348: printf("[%s]", indexed);
349: indexed = indexreg;
350: } while(indexed);
351: }
352: if (mapchar == 0){
353: switch(ins){
354: case CASEB:
355: case CASEW:
356: case CASEL:
357: casebody(insoutvar[1], insoutvar[2]);
358: break;
359: default:
360: break;
361: }
362: }
363: ret: ;
364:
365: dotinc = incp;
366: }
367:
368: casebody(base, limit)
369: long base;
370: long limit;
371: {
372: int i;
373: u_int baseincp;
374: u_int advincp;
375: struct as_number *valuep;
376: #define OSIZE (sizeof(short))
377: argno = 0;
378: baseincp = incp;
379: for (i = 0; i <= limit; i++) {
380: printc(EOR);
381: printf(" %R: ", i + base);
382: valuep = snarfreloc(OSIZE, 0);
383: advincp = incp;
384: incp = baseincp;
385: dispaddress(valuep, OC_CONS(OC_WDISP, R_PC));
386: incp = advincp;
387: }
388: }
389:
390: /*
391: * magic values to mung an offset to a register into
392: * something that psymoff can understand.. all magic
393: */
394: /* 0 1 2 3 4 */
395: static long magic_masks[5] = {0, 0x80, 0x8000, 0, 0};
396: static long magic_compl[5] = {0, 0x100, 0x10000,0, 0};
397: /*
398: * Snarf up some bytes, and put in the magic relocation flags
399: */
400: static numberp snarfreloc(nbytes)
401: int nbytes;
402: {
403: numberp back;
404: back = snarf(nbytes);
405: if (back->num_ulong[0] & magic_masks[nbytes])
406: back->num_ulong[0] -= magic_compl[nbytes];
407: return(back);
408: }
409: /*
410: * The following code is NOT portable from the PDP 11 to the VAX
411: * because of the byte ordering problem.
412: */
413: static numberp snarf(nbytes)
414: int nbytes;
415: {
416: register int i;
417:
418: static struct as_number backnumber;
419: static struct as_number znumber; /* init'ed to 0 */
420:
421: backnumber = znumber;
422: for (i = 0; i < nbytes; i++)
423: backnumber.num_uchar[i] = snarfuchar();
424: return(&backnumber);
425: }
426:
427: /*
428: * Read one single character, and advance the dot
429: */
430: static u_char
431: snarfuchar()
432: {
433: u_char back;
434: /*
435: * assert: bchkget and inkdot don't have side effects
436: */
437: back = (u_char)bchkget(inkdot(incp), idsp);
438: incp += 1;
439: return(back);
440: }
441:
442: /*
443: * normal operand; return non zero pointer to register
444: * name if this is an index instruction.
445: */
446: char *operandout(mode, optype)
447: u_char mode;
448: u_char optype;
449: {
450: char *r;
451: int regnumber;
452: int nbytes;
453:
454: regnumber = OC_REGEXT(mode);
455: r = insregname(regnumber);
456: switch (OC_AMEXT(mode)){
457: case OC_IMM0:
458: case OC_IMM1:
459: case OC_IMM2:
460: case OC_IMM3:
461: shortliteral(mode, optype);
462: return(0);
463: case OC_INDEX:
464: return(r); /* will be printed later */
465: case OC_REG:
466: printf("%s", r);
467: return(0);
468: case OC_DREG:
469: printf("(%s)", r);
470: return(0);
471: case OC_ADREG:
472: printf("-(%s)", r);
473: return(0);
474: case OC_DAIREG:
475: printc('*');
476: case OC_AIREG:
477: if (regnumber == R_PC){
478: pcimmediate(mode, optype);
479: } else {
480: printf("(%s)+", r);
481: }
482: return(0);
483: case OC_DBDISP:
484: printc('*');
485: case OC_BDISP:
486: nbytes = 1;
487: break;
488: case OC_DWDISP:
489: printc('*');
490: case OC_WDISP:
491: nbytes = 2;
492: break;
493: case OC_DLDISP:
494: printc('*');
495: case OC_LDISP:
496: nbytes = 4;
497: break;
498: }
499: dispaddress(snarfreloc(nbytes), mode);
500: return(0);
501: }
502:
503: dispaddress(valuep, mode)
504: numberp valuep;
505: u_char mode;
506: {
507: int regnumber = OC_REGEXT(mode);
508:
509: switch(OC_AMEXT(mode)){
510: case OC_BDISP:
511: case OC_DBDISP:
512: case OC_WDISP:
513: case OC_DWDISP:
514: case OC_LDISP:
515: case OC_DLDISP:
516: if (regnumber == R_PC){
517: /* PC offset addressing */
518: valuep->num_ulong[0] += inkdot(incp);
519: }
520: }
521: if (regnumber == R_PC)
522: psymoff(valuep->num_ulong[0], type, &insoutfmt[0]);
523: else { /* } */
524: printf(LPRMODE, valuep->num_ulong[0]);
525: printf(insoutfmt);
526: printf("(%s)", insregname(regnumber));
527: }
528: savevar((long)valuep->num_ulong[0]);
529: }
530:
531: /*
532: * get a register name
533: */
534: static char *
535: insregname(regnumber)
536: int regnumber;
537: {
538: char *r;
539: r = regname[regnumber];
540: return(r);
541: }
542:
543: /*
544: * print out a short literal
545: */
546: shortliteral(mode, optype)
547: u_char mode;
548: u_char optype;
549: {
550: savevar((long)mode);
551: switch(A_TYPEXT(optype)){
552: case TYPF:
553: case TYPD:
554: case TYPG:
555: case TYPH:
556: printf("$%s", fltimm[mode]);
557: break;
558: default:
559: printf("$%r", mode);
560: break;
561: }
562: }
563:
564: pcimmediate(mode, optype)
565: u_char mode;
566: u_char optype;
567: {
568: int nbytes;
569:
570: printc('$');
571: if (mode == OC_CONS(OC_DAIREG, R_PC)){ /* PC absolute, always 4 bytes*/
572: dispaddress(snarfreloc(4), mode);
573: return;
574: }
575: nbytes = ty_nbyte[A_TYPEXT(optype)];
576: if (! ty_NORELOC[A_TYPEXT(optype)]){
577: dispaddress(snarfreloc(nbytes), mode);
578: return;
579: }
580: bignumprint(nbytes, optype);
581: }
582:
583: bignumprint(nbytes, optype)
584: int nbytes;
585: u_char optype;
586: {
587: numberp valuep;
588: int leading_zero = 1;
589: register int bindex;
590: register int nindex;
591: register int ch;
592:
593: valuep = snarf(nbytes);
594: switch(A_TYPEXT(optype)){
595: case TYPF:
596: printf("0f%f", valuep->num_num.numFf_float.Ff_value);
597: break;
598: case TYPD:
599: printf("0d%f", valuep->num_num.numFd_float.Fd_value);
600: break;
601: case TYPG:
602: printf("0g::"); goto qprint;
603: case TYPH:
604: printf("0h::"); goto qprint;
605: case TYPQ:
606: case TYPO:
607: qprint:
608: for (bindex = nbytes - 1; bindex >= 0; --bindex){
609: for (nindex = 4; nindex >= 0; nindex -= 4){
610: ch = (valuep->num_uchar[bindex] >> nindex);
611: ch &= 0x0F;
612: if ( ! (leading_zero &= (ch == 0) ) ){
613: if (ch <= 0x09)
614: printc(ch + '0');
615: else
616: printc(ch - 0x0A + 'a');
617: }
618: }
619: }
620: break;
621: }
622: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.