[unix-history] / usr / src / old / as.vax / ascode.c

/* Copyright (c) 1980 Regents of the University of California */
static	char sccsid[] = "@(#)ascode.c 4.1 %G%";
#include <stdio.h>
#include <sys/types.h>
#include <a.out.h>
#include "as.h"
#include "assyms.h"

insout(op, ap, nact)
	struct arg *ap;
{
	int jxxflg;

	op &= 0xFF;
	jxxflg = nact;
	if (nact < 0)
		nact = -nact;
	if (passno == 1) {
		register struct arg 	*ap2;
		register struct instab 	*ip;
		int 			i,nexp;
		ip = itab[op];
		nexp = ip->nargs;
		if (nact < nexp)
			yyerror("Too few arguments");
		if (nact > nexp) {
			yyerror("Too many arguments");
			nact = nexp;
		}
		/*
		 *	Check argument compatability with instruction template
		 */
		for (ap2 = ap+nact, i = nact; --i >= 0;)
			argcompat(--ap2, ip->argtype[i], i+1);
	}
	if (jxxflg < 0)
		ijxout(op, ap, nact);
	else putins(op, ap, nact);
}

argcompat(act, exp, i)
	struct arg *act;
	int exp,i;
{
	register 	at,atm;

	at = act->atype;
	atm = at & AMASK;

	if ( (exp & ACCB) && (!((atm == AEXP) || (atm == AIMM))) ){
		yyerror("arg %d, branch displacement must be an expression",i);
		return;
	}
	if ((exp & ACCA) && (atm == AREG)) {
		yyerror("arg %d, addressing a register",i);
		return;
	}
	if ((exp&ACCW) && (atm==AIMM) && !(at&ASTAR)) {
		yyerror("arg %d, modifying a constant",i);
		return;
	}
	if (at & AINDX) {
		if (act->areg2==017) {
			yyerror("arg %d, PC used as index",i);
			return;
		}
		if (atm==AREG) {
			yyerror("arg %d, indexing the register file",i);
			return;
		}
		if (atm==AIMM) {
			yyerror("arg %d, indexing a constant",i);
			return;
		}
		if (((atm==ADECR) || (atm==AINCR)) && (act->areg1==act->areg2)) {
			yyerror("arg %d, indexing with modified register",i);
			return;
		}
	}
}

extern	int d124;
	int len124[] = 	{0,LEN1,LEN2,0,LEN4};
	char mod124[] = {0,0x00,0x20,0,0x40};

putins(op, ap, n)
	/*
	 *	n had better be positive
	 */
	register struct arg *ap;
{
	register struct exp 	*xp;
	register int 		a;
	int 			i,xtrab;

#ifdef DEBUG
	fflush(stdout);
#endif
	if (passno == 2)
		goto PASS2;

	dotp->xvalue += n+1;	/* 1 for the opcode, at least 1 per arg */
	for (i=0; i<n; i++,ap++) {/* some args take more than 1 byte */
	    xtrab = 0;
	    a=ap->atype;
	    if (a & AINDX)
		dotp->xvalue++;
	    switch (a&~(AINDX|ASTAR)) {
		case AEXP: 
			a = itab[op]->argtype[i];
			if (a == ACCB+TYPB)
				break;
			if (a==ACCB+TYPW){
				dotp->xvalue++;
				break;
			}
			/*
			 *	Reduces to PC relative
			 */
			xtrab++;
			dotp->xvalue += ap->dispsize;
			break;
		
		case ADISP: 
			xp=ap->xp;
			if ((xp->xtype&XTYPE)!=XABS || xp->xtype&XFORW){
				dotp->xvalue += ap->dispsize;
				break;
			}
			if (xp->xvalue==0 && !(a&ASTAR))
				break;
			dotp->xvalue++;
			if ((xp->xvalue<MINBYTE) || (xp->xvalue>MAXBYTE))
				dotp->xvalue++;
			if ((xp->xvalue<MINWORD) || (xp->xvalue>MAXWORD))
				dotp->xvalue += 2;
			break;

		case AIMM: 
			if (ap->atype&ASTAR) a=TYPL;
			else {
				a = itab[op]->argtype[i];
				if (a&ACCA)
					a = TYPL;
				else
					a &= TYPMASK;
				xp = ap->xp;
				if (   ((xp->xtype&XTYPE)==XABS)
				    && (!(xp->xtype&XFORW))
				    && (xp->xvalue>=0)
				    && (xp->xvalue<=63) 
				    && (xp->yvalue == 0)
				    && (a != TYPD)
				    && (a != TYPF)
				)
						break;
			}
			switch (a) {
			case TYPD:
			case TYPF:
				if (   !(((xp->xtype&XTYPE)==XABS)
				    && (!(xp->xtype&XFORW))
				    && (slitflt(xp)))
				){
				/* it is NOT short */
					dotp->xvalue += ((a==TYPF)?
						4 : 8);
				}
				break;
			case TYPQ: 
				dotp->xvalue += 8;break;
			case TYPL:
				dotp->xvalue += 4;break;
			case TYPW: 
				dotp->xvalue += 2;break;
			case TYPB: 
				dotp->xvalue += 1;break;
			}	/*end of the switch on a*/
	    }	/*end of the switch on the type*/
	}	/*end of looping for all arguments*/
	return;

PASS2:

#ifdef UNIX
	outb(op); /* the opcode */
#endif UNIX
#ifdef VMS
	*vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)op;
	dotp->xvalue += 1;
#endif VMS

	for (i=0; i<n; i++,ap++) {/* now for the arguments */
		a=ap->atype;
		xp=ap->xp;
		xtrab=0;
		if (a&AINDX) {
#ifdef UNIX
			{ outb(0x40 | ap->areg2); }
#endif UNIX
#ifdef VMS
			{ *vms_obj_ptr++ = -1;
			  *vms_obj_ptr++ = (0x40 | ap->areg2);
			  dotp->xvalue += 1; }
#endif VMS
			a &= ~AINDX;
		}
		if (a&ASTAR) {
			ap->areg1 |= 0x10;
			a &= ~ASTAR;
		}
		switch (a) {
		case AREG:		/* %r */
			ap->areg1 |= 0x50;
			break; 
		case ABASE:		/* (%r) */
			ap->areg1 |= 0x60;
			break; 
		case ADECR: 		/* -(%r) */
			ap->areg1 |= 0x70;
			break; 
		case AINCR:		/* (%r) */
			ap->areg1 |= 0x80;
			break;
		case AEXP: /* expr */
			a = itab[op]->argtype[i];
			if (a == ACCB+TYPB) {
				ap->areg1 = a = 
					xp->xvalue - (dotp->xvalue + 1);
				if (a<MINBYTE || a>MAXBYTE)
					yyerror("Branch too far"); break;
			}
			if (a == ACCB+TYPW) {
				ap->areg1 = a = xp->xvalue
					-= dotp->xvalue + 2;
				xp->xtype = XABS;
				if (a<MINWORD || a>MAXWORD) 
					yyerror("Branch too far");
				xp->xvalue = a>>8;
				xtrab = LEN1;
				break;
			}
			/* reduces to expr(pc) mode */
			ap->areg1 |= (0xAF + mod124[ap->dispsize]);
			xtrab = len124[ap->dispsize]+PCREL;
			break;
		
		case ADISP: /* expr(%r) */
			ap->areg1 |= 0xA0;
			if ((xp->xtype&XTYPE)!=XABS || xp->xtype&XFORW){
				ap->areg1 += mod124[ap->dispsize];
				xtrab=len124[ap->dispsize];
				break;
			}
			if (xp->xvalue==0 && !(ap->areg1&0x10)) {
				ap->areg1 ^= 0xC0;
				break;
			}
			xtrab=LEN1;
			if ((xp->xvalue<MINBYTE) || (xp->xvalue>MAXBYTE)){
				ap->areg1 += 0x20;
				xtrab=LEN2;
			}
			if ((xp->xvalue<MINWORD) || (xp->xvalue>MAXWORD)){
				ap->areg1 += 0x20;
				xtrab=LEN4;
			}
			break;
		
		case AIMM:  /* $expr */
			if (ap->atype&ASTAR)
				a=TYPL;
			else {
				a = itab[op]->argtype[i];
				if (a&ACCA)
					a=TYPL;
				else
					a &= TYPMASK;
				if (    ( (xp->xtype&XTYPE) == XABS) 
				    && !(xp->xtype&XFORW)
				    &&  (xp->xvalue >= 0)
				    &&  (xp->xvalue <= 63)
				    &&  (xp->yvalue == 0)
				    &&  (a != TYPF)
				    &&  (a != TYPD) ) {
					ap->areg1 = xp->xvalue;
					break;
				}
			}
			ap->areg1 |= 0x8F;
			switch (a) {
			case TYPD:
			case TYPF:
				if (   ((xp->xtype&XTYPE)==XABS)
				    && (!(xp->xtype&XFORW))
				    && (slitflt(xp))
				){
					ap->areg1=extlitflt(xp);
				} else {
					xtrab = (a==TYPF) ? LEN4: LEN8;
				}
				break;
			case TYPQ: xtrab = LEN8; break;
			case TYPL: xtrab = LEN4; break;
			case TYPW: xtrab = LEN2; break;
			case TYPB: xtrab = LEN1; break;
			}	
			break;
		
		}	/*end of the switch on a*/
		/*
		 *	use the first byte to describe the argument
		 */
#ifdef UNIX
		outb(ap->areg1);
#endif UNIX
#ifdef VMS
		*vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)(ap->areg1);
		dotp->xvalue += 1;
		if ((vms_obj_ptr-sobuf) > 400) {
			write(objfil,sobuf,vms_obj_ptr-sobuf);
			vms_obj_ptr=sobuf+1;
		}
#endif VMS
		if (xtrab) 
			/*
			 *	Floating point numbers are written to a.out
			 *	by outrel; they require that the least significant
			 *	4 bytes of an 8 byte double precision number
			 *	immediately follow the field xvalue, which
			 *	they do.
			 */
			outrel(&xp->xvalue, xtrab, xp->xtype, xp->xname);
	}	/*end of the for to pick up all arguments*/
}
Commit	Line	Data
cb3898cb BJ	1	/* Copyright (c) 1980 Regents of the University of California */
	2	static char sccsid[] = "@(#)ascode.c 4.1 %G%";
	3	#include <stdio.h>
	4	#include <sys/types.h>
	5	#include <a.out.h>
	6	#include "as.h"
	7	#include "assyms.h"
	8
	9	insout(op, ap, nact)
	10	struct arg *ap;
	11	{
	12	int jxxflg;
	13
	14	op &= 0xFF;
	15	jxxflg = nact;
	16	if (nact < 0)
	17	nact = -nact;
	18	if (passno == 1) {
	19	register struct arg *ap2;
	20	register struct instab *ip;
	21	int i,nexp;
	22	ip = itab[op];
	23	nexp = ip->nargs;
	24	if (nact < nexp)
	25	yyerror("Too few arguments");
	26	if (nact > nexp) {
	27	yyerror("Too many arguments");
	28	nact = nexp;
	29	}
	30	/*
	31	* Check argument compatability with instruction template
	32	*/
	33	for (ap2 = ap+nact, i = nact; --i >= 0;)
	34	argcompat(--ap2, ip->argtype[i], i+1);
	35	}
	36	if (jxxflg < 0)
	37	ijxout(op, ap, nact);
	38	else putins(op, ap, nact);
	39	}
	40
	41	argcompat(act, exp, i)
	42	struct arg *act;
	43	int exp,i;
	44	{
	45	register at,atm;
	46
	47	at = act->atype;
	48	atm = at & AMASK;
	49
	50	if ( (exp & ACCB) && (!((atm == AEXP) \|\| (atm == AIMM))) ){
	51	yyerror("arg %d, branch displacement must be an expression",i);
	52	return;
	53	}
	54	if ((exp & ACCA) && (atm == AREG)) {
	55	yyerror("arg %d, addressing a register",i);
	56	return;
	57	}
	58	if ((exp&ACCW) && (atm==AIMM) && !(at&ASTAR)) {
	59	yyerror("arg %d, modifying a constant",i);
	60	return;
	61	}
	62	if (at & AINDX) {
	63	if (act->areg2==017) {
	64	yyerror("arg %d, PC used as index",i);
65	return;
66	}
67	if (atm==AREG) {
68	yyerror("arg %d, indexing the register file",i);
69	return;
70	}
71	if (atm==AIMM) {
72	yyerror("arg %d, indexing a constant",i);
73	return;
74	}
75	if (((atm==ADECR) \|\| (atm==AINCR)) && (act->areg1==act->areg2)) {
76	yyerror("arg %d, indexing with modified register",i);
77	return;
78	}
79	}
80	}
81
82	extern int d124;
83	int len124[] = {0,LEN1,LEN2,0,LEN4};
84	char mod124[] = {0,0x00,0x20,0,0x40};
85
86	putins(op, ap, n)
87	/*
88	* n had better be positive
89	*/
90	register struct arg *ap;
91	{
92	register struct exp *xp;
93	register int a;
94	int i,xtrab;
95
96	#ifdef DEBUG
97	fflush(stdout);
98	#endif
99	if (passno == 2)
100	goto PASS2;
101
102	dotp->xvalue += n+1; /* 1 for the opcode, at least 1 per arg */
103	for (i=0; i<n; i++,ap++) {/* some args take more than 1 byte */
104	xtrab = 0;
105	a=ap->atype;
106	if (a & AINDX)
107	dotp->xvalue++;
108	switch (a&~(AINDX\|ASTAR)) {
109	case AEXP:
110	a = itab[op]->argtype[i];
111	if (a == ACCB+TYPB)
112	break;
113	if (a==ACCB+TYPW){
114	dotp->xvalue++;
115	break;
116	}
117	/*
118	* Reduces to PC relative
119	*/
120	xtrab++;
121	dotp->xvalue += ap->dispsize;
122	break;
123
124	case ADISP:
125	xp=ap->xp;
126	if ((xp->xtype&XTYPE)!=XABS \|\| xp->xtype&XFORW){
127	dotp->xvalue += ap->dispsize;
128	break;
129	}
130	if (xp->xvalue==0 && !(a&ASTAR))
131	break;
132	dotp->xvalue++;
133	if ((xp->xvalue<MINBYTE) \|\| (xp->xvalue>MAXBYTE))
134	dotp->xvalue++;
135	if ((xp->xvalue<MINWORD) \|\| (xp->xvalue>MAXWORD))
136	dotp->xvalue += 2;
137	break;
138
139	case AIMM:
140	if (ap->atype&ASTAR) a=TYPL;
141	else {
142	a = itab[op]->argtype[i];
143	if (a&ACCA)
144	a = TYPL;
145	else
146	a &= TYPMASK;
147	xp = ap->xp;
148	if ( ((xp->xtype&XTYPE)==XABS)
149	&& (!(xp->xtype&XFORW))
150	&& (xp->xvalue>=0)
151	&& (xp->xvalue<=63)
152	&& (xp->yvalue == 0)
153	&& (a != TYPD)
154	&& (a != TYPF)
155	)
156	break;
157	}
158	switch (a) {
159	case TYPD:
160	case TYPF:
161	if ( !(((xp->xtype&XTYPE)==XABS)
162	&& (!(xp->xtype&XFORW))
163	&& (slitflt(xp)))
164	){
165	/* it is NOT short */
166	dotp->xvalue += ((a==TYPF)?
167	4 : 8);
168	}
169	break;
170	case TYPQ:
171	dotp->xvalue += 8;break;
172	case TYPL:
173	dotp->xvalue += 4;break;
174	case TYPW:
175	dotp->xvalue += 2;break;
176	case TYPB:
177	dotp->xvalue += 1;break;
178	} /end of the switch on a/
179	} /end of the switch on the type/
180	} /end of looping for all arguments/
181	return;
182
183	PASS2:
184
185	#ifdef UNIX
186	outb(op); /* the opcode */
187	#endif UNIX
188	#ifdef VMS
189	vms_obj_ptr++ = -1; vms_obj_ptr++ = (char)op;
190	dotp->xvalue += 1;
191	#endif VMS
192
193	for (i=0; i<n; i++,ap++) {/* now for the arguments */
194	a=ap->atype;
195	xp=ap->xp;
196	xtrab=0;
197	if (a&AINDX) {
198	#ifdef UNIX
199	{ outb(0x40 \| ap->areg2); }
200	#endif UNIX
201	#ifdef VMS
202	{ *vms_obj_ptr++ = -1;
203	*vms_obj_ptr++ = (0x40 \| ap->areg2);
204	dotp->xvalue += 1; }
205	#endif VMS
206	a &= ~AINDX;
207	}
208	if (a&ASTAR) {
209	ap->areg1 \|= 0x10;
210	a &= ~ASTAR;
211	}
212	switch (a) {
213	case AREG: /* %r */
214	ap->areg1 \|= 0x50;
215	break;
216	case ABASE: /* (%r) */
217	ap->areg1 \|= 0x60;
218	break;
219	case ADECR: /* -(%r) */
220	ap->areg1 \|= 0x70;
221	break;
222	case AINCR: /* (%r) */
223	ap->areg1 \|= 0x80;
224	break;
225	case AEXP: /* expr */
226	a = itab[op]->argtype[i];
227	if (a == ACCB+TYPB) {
228	ap->areg1 = a =
229	xp->xvalue - (dotp->xvalue + 1);
230	if (a<MINBYTE \|\| a>MAXBYTE)
231	yyerror("Branch too far"); break;
232	}
233	if (a == ACCB+TYPW) {
234	ap->areg1 = a = xp->xvalue
235	-= dotp->xvalue + 2;
236	xp->xtype = XABS;
237	if (a<MINWORD \|\| a>MAXWORD)
238	yyerror("Branch too far");
239	xp->xvalue = a>>8;
240	xtrab = LEN1;
241	break;
242	}
243	/* reduces to expr(pc) mode */
244	ap->areg1 \|= (0xAF + mod124[ap->dispsize]);
245	xtrab = len124[ap->dispsize]+PCREL;
246	break;
247
248	case ADISP: /* expr(%r) */
249	ap->areg1 \|= 0xA0;
250	if ((xp->xtype&XTYPE)!=XABS \|\| xp->xtype&XFORW){
251	ap->areg1 += mod124[ap->dispsize];
252	xtrab=len124[ap->dispsize];
253	break;
254	}
255	if (xp->xvalue==0 && !(ap->areg1&0x10)) {
256	ap->areg1 ^= 0xC0;
257	break;
258	}
259	xtrab=LEN1;
260	if ((xp->xvalue<MINBYTE) \|\| (xp->xvalue>MAXBYTE)){
261	ap->areg1 += 0x20;
262	xtrab=LEN2;
263	}
264	if ((xp->xvalue<MINWORD) \|\| (xp->xvalue>MAXWORD)){
265	ap->areg1 += 0x20;
266	xtrab=LEN4;
267	}
268	break;
269
270	case AIMM: /* $expr */
271	if (ap->atype&ASTAR)
272	a=TYPL;
273	else {
274	a = itab[op]->argtype[i];
275	if (a&ACCA)
276	a=TYPL;
277	else
278	a &= TYPMASK;
279	if ( ( (xp->xtype&XTYPE) == XABS)
280	&& !(xp->xtype&XFORW)
281	&& (xp->xvalue >= 0)
282	&& (xp->xvalue <= 63)
283	&& (xp->yvalue == 0)
284	&& (a != TYPF)
285	&& (a != TYPD) ) {
286	ap->areg1 = xp->xvalue;
287	break;
288	}
289	}
290	ap->areg1 \|= 0x8F;
291	switch (a) {
292	case TYPD:
293	case TYPF:
294	if ( ((xp->xtype&XTYPE)==XABS)
295	&& (!(xp->xtype&XFORW))
296	&& (slitflt(xp))
297	){
298	ap->areg1=extlitflt(xp);
299	} else {
300	xtrab = (a==TYPF) ? LEN4: LEN8;
301	}
302	break;
303	case TYPQ: xtrab = LEN8; break;
304	case TYPL: xtrab = LEN4; break;
305	case TYPW: xtrab = LEN2; break;
306	case TYPB: xtrab = LEN1; break;
307	}
308	break;
309
310	} /end of the switch on a/
311	/*
312	* use the first byte to describe the argument
313	*/
314	#ifdef UNIX
315	outb(ap->areg1);
316	#endif UNIX
317	#ifdef VMS
318	vms_obj_ptr++ = -1; vms_obj_ptr++ = (char)(ap->areg1);
319	dotp->xvalue += 1;
320	if ((vms_obj_ptr-sobuf) > 400) {
321	write(objfil,sobuf,vms_obj_ptr-sobuf);
322	vms_obj_ptr=sobuf+1;
323	}
324	#endif VMS
325	if (xtrab)
326	/*
327	* Floating point numbers are written to a.out
328	* by outrel; they require that the least significant
329	* 4 bytes of an 8 byte double precision number
330	* immediately follow the field xvalue, which
331	* they do.
332	*/
333	outrel(&xp->xvalue, xtrab, xp->xtype, xp->xname);
334	} /end of the for to pick up all arguments/
335	}