[unix-history] / usr / src / cmd / adb / opset.c

#
/*
 *
 *	UNIX debugger
 *
 */

#include "defs.h"

STRING		errflg;
L_INT		dot;
INT		dotinc;
L_INT		var[];


/* instruction printing */

#define	DOUBLE	0
#define DOUBLW	1
#define	SINGLE	2
#define SINGLW	3
#define	REVERS	4
#define	BRANCH	5
#define	NOADDR	6
#define	DFAULT	7
#define	TRAP	8
#define	SYS	9
#define	SOB	10
#define JMP	11
#define JSR	12


TYPE	struct optab	*OPTAB;
struct optab {
	int	mask;
	int	val;
	int	itype;
	char	*iname;
} optab[] {
	0107777, 0010000, DOUBLE, "mov",
	0107777, 0020000, DOUBLE, "cmp",
	0107777, 0030000, DOUBLE, "bit",
	0107777, 0040000, DOUBLE, "bic",
	0107777, 0050000, DOUBLE, "bis",
	0007777, 0060000, DOUBLE, "add",
	0007777, 0160000, DOUBLE, "su",
	0100077, 0005000, SINGLE, "clr",
	0100077, 0005100, SINGLE, "com",
	0100077, 0005200, SINGLE, "inc",
	0100077, 0005300, SINGLE, "dec",
	0100077, 0005400, SINGLE, "neg",
	0100077, 0005500, SINGLE, "adc",
	0100077, 0005600, SINGLE, "sbc",
	0100077, 0005700, SINGLE, "tst",
	0100077, 0006000, SINGLE, "ror",
	0100077, 0006100, SINGLE, "rol",
	0100077, 0006200, SINGLE, "asr",
	0100077, 0006300, SINGLE, "asl",
	0000077, 0000100, JMP,    "jmp",
	0000077, 0000300, SINGLE, "swab",
	0000077, 0170100, SINGLW, "ldfps",
	0000077, 0170200, SINGLW, "stfps",
	0000077, 0170300, SINGLW, "stst",
	0000077, 0170400, SINGLW, "clrf",
	0000077, 0170500, SINGLW, "tstf",
	0000077, 0170600, SINGLW, "absf",
	0000077, 0170700, SINGLW, "negf",
	0000077, 0006700, SINGLW, "sxt",
	0000077, 0006600, SINGLW, "mtpi",
	0000077, 0106600, SINGLW, "mtpd",
	0000077, 0006500, SINGLW, "mfpi",
	0000077, 0106500, SINGLW, "mfpd",
	0000777, 0070000, REVERS, "mul",
	0000777, 0071000, REVERS, "div",
	0000777, 0072000, REVERS, "ash",
	0000777, 0073000, REVERS, "ashc",
	LOBYTE,  0000400, BRANCH, "br",
	LOBYTE,  0001000, BRANCH, "bne",
	LOBYTE,  0001400, BRANCH, "beq",
	LOBYTE,  0002000, BRANCH, "bge",
	LOBYTE,  0002400, BRANCH, "blt",
	LOBYTE,  0003000, BRANCH, "bgt",
	LOBYTE,  0003400, BRANCH, "ble",
	LOBYTE,  0100000, BRANCH, "bpl",
	LOBYTE,  0100400, BRANCH, "bmi",
	LOBYTE,  0101000, BRANCH, "bhi",
	LOBYTE,  0101400, BRANCH, "blos",
	LOBYTE,  0102000, BRANCH, "bvc",
	LOBYTE,  0102400, BRANCH, "bvs",
	LOBYTE,  0103000, BRANCH, "bcc",
	LOBYTE,  0103400, BRANCH, "bcs",
	0000000, 0000000, NOADDR, "halt",
	0000000, 0000001, NOADDR, "wait",
	0000000, 0000002, NOADDR, "rti",
	0000000, 0000003, NOADDR, "bpt",
	0000000, 0000004, NOADDR, "iot",
	0000000, 0000005, NOADDR, "reset",
	LOBYTE,  0171000, REVERS, "mulf",
	LOBYTE,  0171400, REVERS, "modf",
	LOBYTE,  0172000, REVERS, "addf",
	LOBYTE,  0172400, REVERS, "movf",
	LOBYTE,  0173000, REVERS, "subf",
	LOBYTE,  0173400, REVERS, "cmpf",
	LOBYTE,  0174000, DOUBLW, "movf",
	LOBYTE,  0174400, REVERS, "divf",
	LOBYTE,  0175000, DOUBLW, "movei",
	LOBYTE,  0175400, DOUBLW, "movfi",
	LOBYTE,  0176000, DOUBLW, "movfo",
	LOBYTE,  0176400, REVERS, "movie",
	LOBYTE,  0177000, REVERS, "movif",
	LOBYTE,  0177400, REVERS, "movof",
	0000000, 0170000, NOADDR, "cfcc",
	0000000, 0170001, NOADDR, "setf",
	0000000, 0170002, NOADDR, "seti",
	0000000, 0170011, NOADDR, "setd",
	0000000, 0170012, NOADDR, "setl",
	0000777, 0004000, JSR,    "jsr",
	0000777, 0074000, DOUBLE, "xor",
	0000007, 0000200, SINGLE, "rts",
	0000017, 0000240, DFAULT, "cflg",
	0000017, 0000260, DFAULT, "sflg",
	LOBYTE,  0104000, TRAP,   "emt",
	LOBYTE,  0104400, SYS,    "sys",
	0000077, 0006400, TRAP,   "mark",
	0000777, 0077000, SOB,    "sob",
	0000007, 0000230, TRAP,   "spl",
	0177777, 0000000, DFAULT, "",
};

#define SYSTAB struct systab
SYSTAB {
	int	argc;
	char	*sname;
} systab[] {
	1, "indir",
	0, "exit",
	0, "fork",
	2, "read",
	2, "write",
	2, "open",
	0, "close",
	0, "wait",
	2, "creat",
	2, "link",
	1, "unlink",
	2, "exec",
	1, "chdir",
	0, "time",
	3, "mknod",
	2, "chmod",
	2, "chown",
	1, "break",
	2, "stat",
	2, "seek",
	0, "getpid",
	3, "mount",
	1, "umount",
	0, "setuid",
	0, "getuid",
	0, "stime",
	3, "ptrace",
	0, "alarm",
	1, "fstat",
	0, "pause",
	1, "30",
	1, "stty",
	1, "gtty",
	0, "access",
	0, "nice",
	0, "sleep",
	0, "sync",
	1, "kill",
	0, "csw",
	0, "setpgrp",
	0, "tell",
	0, "dup",
	0, "pipe",
	1, "times",
	4, "profil",
	0, "tiu",
	0, "setgid",
	0, "getgid",
	2, "signal",
	0, "49",
	0, "50",
	0, "51",
	0, "52",
	0, "53",
	0, "54",
	0, "55",
	0, "56",
	0, "57",
	0, "58",
	0, "59",
	0, "60",
	0, "61",
	0, "62",
	0, "63",
};

STRING	regname[] { "r0", "r1", "r2", "r3", "r4", "r5", "sp", "pc"};

POS	type, space, incp;

printins(f,idsp,ins)
REG INT		ins;
{
	INT		byte;
	REG OPTAB	p;

	type=DSYM; space=idsp; incp=2;
	FOR p=optab;; p++
	DO	IF (ins & ~p->mask) == p->val
		THEN	break;
		FI
	OD
	prints(p->iname); byte=ins&0100000; ins &= p->mask;
	switch (p->itype) {

	    case JMP:
		type=ISYM;

	    case SINGLE:
		IF byte THEN printc('b'); FI
	    case SINGLW:
		paddr("%8t",ins);
		break;

	    case REVERS:
		doubl(ins&077,(ins>>6)&07);
		break;

	    case JSR:
		type=ISYM;

	    case DOUBLE:
		IF byte THEN printc('b'); FI
	    case DOUBLW:
		doubl(ins>>6,ins);

	    case NOADDR:
		break;

	    case SOB:
		paddr("%8t",(ins>>6)&07);
		branch(",",-(ins&077));
		break;

	    case BRANCH:
		branch("%8t",ins);
		break;

	    case SYS:
		BEGIN
		   INT		indir;
		   REG INT	w;
		   printf("%8t%s", systab[ins &= 077].sname);
		   IF ins==0 ANDF f==0 ANDF idsp!=NSP	/* indir */
		   THEN w=dot; dot=chkget(inkdot(2),idsp);
			prints(" {");
			indir=get(dot,DSP);
			IF errflg
			THEN errflg=0; printc('?');
			ELSE printins(1,DSP,indir);
			FI
			printc('}');
			dot=w; incp=4;
		   ELSE w = systab[ins].argc;
			WHILE w-- ANDF idsp!=NSP
			DO prints("; ");
			   psymoff(leng(get(inkdot(incp),idsp)), NSYM, "");
			   incp += 2;
			OD
		   FI
		END
		break;

	    case TRAP:
	    case DFAULT:
	    default:
		printf("%8t%o", ins);
	}
	dotinc=incp;
}

doubl(a,b)
{
	paddr("%8t",a); paddr(",",b);
}

branch(s,ins)
STRING		s;
REG INT		ins;
{
	printf(s);
	IF ins&0200 THEN ins |= 0177400; FI
	ins = shorten(dot) + (ins<<1) + 2;
	psymoff(leng(ins),ISYM,"");
}

paddr(s, a)
STRING		s;
REG INT		a;
{
	REG INT		r;

	var[2]=var[1];
	r = a&07; a &= 070;

	printf(s);
	IF r==7 ANDF a&020
	THEN IF a&010 THEN printc('*'); FI
	     IF a&040
	     THEN IF space==NSP
		  THEN printc('?');
		  ELSE	var[1]=chkget(inkdot(incp),space) + shorten(inkdot(incp+2));
		       psymoff(var[1],(a&010?DSYM:type),"");
		  FI
	     ELSE printc('$');
		  IF space==NSP
		  THEN printc('?');
		  ELSE var[1]=chkget(inkdot(incp), space);
			psymoff(var[1], (a&010?type:NSYM), "");
		  FI
	     FI
	     incp += 2;
	     return;
	FI
	r = regname[r];
	switch (a) {
	    /* r */
	    case 000:
		prints(r);
		return;

	    /* (r) */
	    case 010:
		printf("(%s)", r);
		return;

	    /* *(r)+ */
	    case 030:
		printc('*');

	    /* (r)+ */
	    case 020:
		printf("(%s)+", r);
		return;

	    /* *-(r) */
	    case 050:
		printc('*');

	    /* -(r) */
	    case 040:
		printf("-(%s)", r);
		return;

	    /* *x(r) */
	    case 070:
		printc('*');

	    /* x(r) */
	    case 060:
		IF space==NSP
		THEN printc('?');
		ELSE	var[1]=chkget(inkdot(incp), space);
			psymoff(var[1], (a==070?type:NSYM), "");
		FI
		incp += 2;
		printf("(%s)", r);
		return;
	}
}
Commit	Line	Data
d94e2462 M	1	#
	2	/*
	3	*
	4	* UNIX debugger
	5	*
	6	*/
	7
	8	#include "defs.h"
	9
	10	STRING errflg;
	11	L_INT dot;
	12	INT dotinc;
	13	L_INT var[];
	14
	15
	16	/* instruction printing */
	17
	18	#define DOUBLE 0
	19	#define DOUBLW 1
	20	#define SINGLE 2
	21	#define SINGLW 3
	22	#define REVERS 4
	23	#define BRANCH 5
	24	#define NOADDR 6
	25	#define DFAULT 7
	26	#define TRAP 8
	27	#define SYS 9
	28	#define SOB 10
	29	#define JMP 11
	30	#define JSR 12
	31
	32
	33	TYPE struct optab *OPTAB;
	34	struct optab {
	35	int mask;
	36	int val;
	37	int itype;
	38	char *iname;
	39	} optab[] {
	40	0107777, 0010000, DOUBLE, "mov",
	41	0107777, 0020000, DOUBLE, "cmp",
	42	0107777, 0030000, DOUBLE, "bit",
	43	0107777, 0040000, DOUBLE, "bic",
	44	0107777, 0050000, DOUBLE, "bis",
	45	0007777, 0060000, DOUBLE, "add",
	46	0007777, 0160000, DOUBLE, "su",
	47	0100077, 0005000, SINGLE, "clr",
	48	0100077, 0005100, SINGLE, "com",
	49	0100077, 0005200, SINGLE, "inc",
	50	0100077, 0005300, SINGLE, "dec",
	51	0100077, 0005400, SINGLE, "neg",
	52	0100077, 0005500, SINGLE, "adc",
	53	0100077, 0005600, SINGLE, "sbc",
	54	0100077, 0005700, SINGLE, "tst",
	55	0100077, 0006000, SINGLE, "ror",
	56	0100077, 0006100, SINGLE, "rol",
	57	0100077, 0006200, SINGLE, "asr",
	58	0100077, 0006300, SINGLE, "asl",
	59	0000077, 0000100, JMP, "jmp",
	60	0000077, 0000300, SINGLE, "swab",
	61	0000077, 0170100, SINGLW, "ldfps",
	62	0000077, 0170200, SINGLW, "stfps",
	63	0000077, 0170300, SINGLW, "stst",
	64	0000077, 0170400, SINGLW, "clrf",
65	0000077, 0170500, SINGLW, "tstf",
66	0000077, 0170600, SINGLW, "absf",
67	0000077, 0170700, SINGLW, "negf",
68	0000077, 0006700, SINGLW, "sxt",
69	0000077, 0006600, SINGLW, "mtpi",
70	0000077, 0106600, SINGLW, "mtpd",
71	0000077, 0006500, SINGLW, "mfpi",
72	0000077, 0106500, SINGLW, "mfpd",
73	0000777, 0070000, REVERS, "mul",
74	0000777, 0071000, REVERS, "div",
75	0000777, 0072000, REVERS, "ash",
76	0000777, 0073000, REVERS, "ashc",
77	LOBYTE, 0000400, BRANCH, "br",
78	LOBYTE, 0001000, BRANCH, "bne",
79	LOBYTE, 0001400, BRANCH, "beq",
80	LOBYTE, 0002000, BRANCH, "bge",
81	LOBYTE, 0002400, BRANCH, "blt",
82	LOBYTE, 0003000, BRANCH, "bgt",
83	LOBYTE, 0003400, BRANCH, "ble",
84	LOBYTE, 0100000, BRANCH, "bpl",
85	LOBYTE, 0100400, BRANCH, "bmi",
86	LOBYTE, 0101000, BRANCH, "bhi",
87	LOBYTE, 0101400, BRANCH, "blos",
88	LOBYTE, 0102000, BRANCH, "bvc",
89	LOBYTE, 0102400, BRANCH, "bvs",
90	LOBYTE, 0103000, BRANCH, "bcc",
91	LOBYTE, 0103400, BRANCH, "bcs",
92	0000000, 0000000, NOADDR, "halt",
93	0000000, 0000001, NOADDR, "wait",
94	0000000, 0000002, NOADDR, "rti",
95	0000000, 0000003, NOADDR, "bpt",
96	0000000, 0000004, NOADDR, "iot",
97	0000000, 0000005, NOADDR, "reset",
98	LOBYTE, 0171000, REVERS, "mulf",
99	LOBYTE, 0171400, REVERS, "modf",
100	LOBYTE, 0172000, REVERS, "addf",
101	LOBYTE, 0172400, REVERS, "movf",
102	LOBYTE, 0173000, REVERS, "subf",
103	LOBYTE, 0173400, REVERS, "cmpf",
104	LOBYTE, 0174000, DOUBLW, "movf",
105	LOBYTE, 0174400, REVERS, "divf",
106	LOBYTE, 0175000, DOUBLW, "movei",
107	LOBYTE, 0175400, DOUBLW, "movfi",
108	LOBYTE, 0176000, DOUBLW, "movfo",
109	LOBYTE, 0176400, REVERS, "movie",
110	LOBYTE, 0177000, REVERS, "movif",
111	LOBYTE, 0177400, REVERS, "movof",
112	0000000, 0170000, NOADDR, "cfcc",
113	0000000, 0170001, NOADDR, "setf",
114	0000000, 0170002, NOADDR, "seti",
115	0000000, 0170011, NOADDR, "setd",
116	0000000, 0170012, NOADDR, "setl",
117	0000777, 0004000, JSR, "jsr",
118	0000777, 0074000, DOUBLE, "xor",
119	0000007, 0000200, SINGLE, "rts",
120	0000017, 0000240, DFAULT, "cflg",
121	0000017, 0000260, DFAULT, "sflg",
122	LOBYTE, 0104000, TRAP, "emt",
123	LOBYTE, 0104400, SYS, "sys",
124	0000077, 0006400, TRAP, "mark",
125	0000777, 0077000, SOB, "sob",
126	0000007, 0000230, TRAP, "spl",
127	0177777, 0000000, DFAULT, "",
128	};
129
130	#define SYSTAB struct systab
131	SYSTAB {
132	int argc;
133	char *sname;
134	} systab[] {
135	1, "indir",
136	0, "exit",
137	0, "fork",
138	2, "read",
139	2, "write",
140	2, "open",
141	0, "close",
142	0, "wait",
143	2, "creat",
144	2, "link",
145	1, "unlink",
146	2, "exec",
147	1, "chdir",
148	0, "time",
149	3, "mknod",
150	2, "chmod",
151	2, "chown",
152	1, "break",
153	2, "stat",
154	2, "seek",
155	0, "getpid",
156	3, "mount",
157	1, "umount",
158	0, "setuid",
159	0, "getuid",
160	0, "stime",
161	3, "ptrace",
162	0, "alarm",
163	1, "fstat",
164	0, "pause",
165	1, "30",
166	1, "stty",
167	1, "gtty",
168	0, "access",
169	0, "nice",
170	0, "sleep",
171	0, "sync",
172	1, "kill",
173	0, "csw",
174	0, "setpgrp",
175	0, "tell",
176	0, "dup",
177	0, "pipe",
178	1, "times",
179	4, "profil",
180	0, "tiu",
181	0, "setgid",
182	0, "getgid",
183	2, "signal",
184	0, "49",
185	0, "50",
186	0, "51",
187	0, "52",
188	0, "53",
189	0, "54",
190	0, "55",
191	0, "56",
192	0, "57",
193	0, "58",
194	0, "59",
195	0, "60",
196	0, "61",
197	0, "62",
198	0, "63",
199	};
200
201	STRING regname[] { "r0", "r1", "r2", "r3", "r4", "r5", "sp", "pc"};
202
203	POS type, space, incp;
204
205	printins(f,idsp,ins)
206	REG INT ins;
207	{
208	INT byte;
209	REG OPTAB p;
210
211	type=DSYM; space=idsp; incp=2;
212	FOR p=optab;; p++
213	DO IF (ins & ~p->mask) == p->val
214	THEN break;
215	FI
216	OD
217	prints(p->iname); byte=ins&0100000; ins &= p->mask;
218	switch (p->itype) {
219
220	case JMP:
221	type=ISYM;
222
223	case SINGLE:
224	IF byte THEN printc('b'); FI
225	case SINGLW:
226	paddr("%8t",ins);
227	break;
228
229	case REVERS:
230	doubl(ins&077,(ins>>6)&07);
231	break;
232
233	case JSR:
234	type=ISYM;
235
236	case DOUBLE:
237	IF byte THEN printc('b'); FI
238	case DOUBLW:
239	doubl(ins>>6,ins);
240
241	case NOADDR:
242	break;
243
244	case SOB:
245	paddr("%8t",(ins>>6)&07);
246	branch(",",-(ins&077));
247	break;
248
249	case BRANCH:
250	branch("%8t",ins);
251	break;
252
253	case SYS:
254	BEGIN
255	INT indir;
256	REG INT w;
257	printf("%8t%s", systab[ins &= 077].sname);
258	IF ins==0 ANDF f==0 ANDF idsp!=NSP /* indir */
259	THEN w=dot; dot=chkget(inkdot(2),idsp);
260	prints(" {");
261	indir=get(dot,DSP);
262	IF errflg
263	THEN errflg=0; printc('?');
264	ELSE printins(1,DSP,indir);
265	FI
266	printc('}');
267	dot=w; incp=4;
268	ELSE w = systab[ins].argc;
269	WHILE w-- ANDF idsp!=NSP
270	DO prints("; ");
271	psymoff(leng(get(inkdot(incp),idsp)), NSYM, "");
272	incp += 2;
273	OD
274	FI
275	END
276	break;
277
278	case TRAP:
279	case DFAULT:
280	default:
281	printf("%8t%o", ins);
282	}
283	dotinc=incp;
284	}
285
286	doubl(a,b)
287	{
288	paddr("%8t",a); paddr(",",b);
289	}
290
291	branch(s,ins)
292	STRING s;
293	REG INT ins;
294	{
295	printf(s);
296	IF ins&0200 THEN ins \|= 0177400; FI
297	ins = shorten(dot) + (ins<<1) + 2;
298	psymoff(leng(ins),ISYM,"");
299	}
300
301	paddr(s, a)
302	STRING s;
303	REG INT a;
304	{
305	REG INT r;
306
307	var[2]=var[1];
308	r = a&07; a &= 070;
309
310	printf(s);
311	IF r==7 ANDF a&020
312	THEN IF a&010 THEN printc('*'); FI
313	IF a&040
314	THEN IF space==NSP
315	THEN printc('?');
316	ELSE var[1]=chkget(inkdot(incp),space) + shorten(inkdot(incp+2));
317	psymoff(var[1],(a&010?DSYM:type),"");
318	FI
319	ELSE printc('$');
320	IF space==NSP
321	THEN printc('?');
322	ELSE var[1]=chkget(inkdot(incp), space);
323	psymoff(var[1], (a&010?type:NSYM), "");
324	FI
325	FI
326	incp += 2;
327	return;
328	FI
329	r = regname[r];
330	switch (a) {
331	/* r */
332	case 000:
333	prints(r);
334	return;
335
336	/* (r) */
337	case 010:
338	printf("(%s)", r);
339	return;
340
341	/* (r)+ /
342	case 030:
343	printc('*');
344
345	/* (r)+ */
346	case 020:
347	printf("(%s)+", r);
348	return;
349
350	/* -(r) /
351	case 050:
352	printc('*');
353
354	/* -(r) */
355	case 040:
356	printf("-(%s)", r);
357	return;
358
359	/* x(r) /
360	case 070:
361	printc('*');
362
363	/* x(r) */
364	case 060:
365	IF space==NSP
366	THEN printc('?');
367	ELSE var[1]=chkget(inkdot(incp), space);
368	psymoff(var[1], (a==070?type:NSYM), "");
369	FI
370	incp += 2;
371	printf("(%s)", r);
372	return;
373	}
374	}
375
376
377