![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ascode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / bin / as|
Return to ascode.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin / as |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)ascode.c 5.1 (Berkeley) 4/24/85";
9: #endif not lint
10:
11: #include <stdio.h>
12: #include "as.h"
13: #include "assyms.h"
14:
15: insout(opcode, ap, nact)
16: struct Opcode opcode;
17: struct arg *ap;
18: int nact;
19: {
20: int jxxflg;
21: reg struct instab *ip; /* the instruction */
22: reg struct arg *ap_walk; /* actual param walk */
23: reg int i;
24: reg int ap_type; /* actual param type */
25: reg int ap_type_mask; /* masked actual param */
26:
27: jxxflg = nact;
28: if (nact < 0)
29: nact = -nact;
30: if (passno == 1) {
31: if (!(ITABCHECK(opcode)))
32: panic("Botched reference into itab");
33: ip = ITABFETCH(opcode);
34: if (nact < ip->i_nargs)
35: yyerror("Too few arguments");
36: if (nact > ip->i_nargs) {
37: yyerror("Too many arguments");
38: nact = ip->i_nargs;
39: }
40: /*
41: * Check argument compatability with instruction template
42: */
43: for (ap_walk = ap, i = 1; i <= nact; ap_walk++, i++){
44: ap_type = ap_walk->a_atype;
45: ap_type_mask = ap_type & AMASK;
46: /*
47: * The switch value is >> by TYPLG so that the switch
48: * code is dense, not implemented as a sequence
49: * of branches but implemented as a casel.
50: * In addition, cases ACCI and ACCR are added to force
51: * dense switch code.
52: * switch on the type of fp
53: */
54: switch( ((fetcharg(ip, i-1)) & ACCESSMASK) >> TYPLG){
55: case ACCI >> TYPLG:
56: case ACCR >> TYPLG:
57: break;
58: case ACCB >> TYPLG:
59: if ( !((ap_type_mask == AEXP) || (ap_type_mask == AIMM)) ){
60: yyerror("arg %d, branch displacement must be an expression",i);
61: return;
62: }
63: break;
64: case ACCA >> TYPLG:
65: switch(ap_type_mask){
66: case AREG: yyerror("arg %d, addressing a register",i);
67: return;
68: case AIMM: if ( !(ap_type & ASTAR) ){
69: yyerror("arg %d, addressing an immediate operand",i);
70: return;
71: }
72: }
73: break;
74: case ACCM >> TYPLG:
75: case ACCW >> TYPLG:
76: switch(ap_type_mask){
77: case AIMM: if (!(ap_type&ASTAR)) {
78: yyerror("arg %d, modifying a constant",i);
79: return;
80: }
81: }
82: break;
83: } /* end of the switch on fp_type */
84: if (ap_type & AINDX) {
85: if (ap_walk->a_areg2==0xF) {
86: yyerror("arg %d, PC used as index",i);
87: return;
88: }
89: switch(ap_type_mask){
90: case AREG: yyerror("arg %d, indexing the register file",i);
91: return;
92: case AIMM: yyerror("arg %d, indexing a constant",i);
93: return;
94: case ADECR:
95: case AINCR: if (ap_walk->a_areg1==ap_walk->a_areg2) {
96: yyerror("arg %d, indexing with modified register",i);
97: return;
98: }
99: break;
100: } /* end of switch on ap_type_mask */
101: } /* end of AINDX */
102: }
103: } /* both passes here */
104: if (jxxflg < 0)
105: ijxout(opcode, ap, nact);
106: else
107: putins(opcode, ap, nact);
108: }
109:
110: extern int d124;
111:
112: putins(opcode, ap, n)
113: struct Opcode opcode;
114: register struct arg *ap;
115: int n; /* Must be positive */
116: {
117: reg struct exp *xp;
118: reg int argtype;
119: int i;
120: int reloc_how;
121: int value;
122:
123: #ifdef DEBUG
124: fflush(stdout);
125: #endif
126: if (passno == 2)
127: goto PASS2;
128:
129: dotp->e_xvalue += n; /* at least one byte per arg */
130: switch(opcode.Op_eopcode){
131: case NEW:
132: case CORE:
133: dotp->e_xvalue += 1; /* 1 byte opcode */
134: break;
135: case ESCD:
136: case ESCF:
137: dotp->e_xvalue += 2; /* 2 byte opcode */
138: break;
139: default:
140: panic("Bad escape opcode");
141: }
142:
143: for (i=0; i<n; i++,ap++) { /* some args take more than 1 byte */
144: argtype = ap->a_atype;
145: if (argtype & AINDX)
146: dotp->e_xvalue++;
147: /*
148: * This switch has been fixed by enumerating the no action
149: * alternatives (those that have 1 one byte of code)
150: * so that a casel instruction is emitted.
151: */
152: switch (argtype&~(AINDX|ASTAR)) {
153: case AREG:
154: case ABASE:
155: case ADECR:
156: case AINCR:
157: break;
158: case AEXP:
159: argtype = fetcharg(ITABFETCH(opcode), i);
160: if (argtype == A_BB)
161: break;
162: if (argtype == A_BW){
163: dotp->e_xvalue++;
164: break;
165: }
166: /*
167: * Reduces to PC relative
168: */
169: dotp->e_xvalue += ap->a_dispsize;
170: break;
171:
172: case ADISP:
173: xp=ap->a_xp;
174: if ((xp->e_xtype&XTYPE)!=XABS || xp->e_xtype&XFORW){
175: dotp->e_xvalue += ap->a_dispsize;
176: break;
177: }
178: if (xp->e_xvalue==0 && !(argtype&ASTAR))
179: break;
180: dotp->e_xvalue += 1;
181: if (ISBYTE(xp->e_xvalue))
182: break;
183: dotp->e_xvalue += 1;
184: if (ISWORD(xp->e_xvalue))
185: break;
186: dotp->e_xvalue += 2;
187: break;
188:
189: case AIMM:
190: if (ap->a_atype&ASTAR) {
191: argtype=TYPL;
192: } else {
193: argtype = fetcharg(ITABFETCH(opcode), i);
194: if (argtype&ACCA)
195: argtype = TYPL;
196: else
197: argtype &= TYPMASK;
198: xp = ap->a_xp;
199: if (immconstant(ap->a_xp, argtype, &value))
200: break;
201: }
202: dotp->e_xvalue += ty_nbyte[argtype];
203: } /*end of the switch on the type*/
204: } /*end of looping for all arguments*/
205: return;
206:
207: PASS2:
208: /*
209: * Output the opcode
210: */
211: switch(opcode.Op_eopcode){
212: case NEW:
213: nnewopcodes++;
214: break;
215: case ESCD:
216: case ESCF:
217: nGHopcodes++;
218: Outb(opcode.Op_eopcode);
219: break;
220: case CORE:
221: break;
222: default:
223: panic("Bad escape opcode");
224: }
225: Outb(opcode.Op_popcode);
226:
227: for (i=0; i<n; i++,ap++) {/* now for the arguments */
228: argtype=ap->a_atype;
229: xp=ap->a_xp;
230: reloc_how = TYPNONE;
231: if (argtype&AINDX) {
232: { Outb(0x40 | ap->a_areg2); }
233: argtype &= ~AINDX;
234: }
235: if (argtype&ASTAR) {
236: ap->a_areg1 |= 0x10;
237: argtype &= ~ASTAR;
238: }
239: switch (argtype) {
240: case AREG: /* %r */
241: ap->a_areg1 |= 0x50;
242: break;
243: case ABASE: /* (%r) */
244: ap->a_areg1 |= 0x60;
245: break;
246: case ADECR: /* -(%r) */
247: ap->a_areg1 |= 0x70;
248: break;
249: case AINCR: /* (%r)+ */
250: ap->a_areg1 |= 0x80;
251: break;
252: case AEXP: /* expr */
253: argtype = fetcharg(ITABFETCH(opcode), i);
254: if (argtype == A_BB) {
255: ap->a_areg1 = argtype =
256: xp->e_xvalue - (dotp->e_xvalue + 1);
257: if ((xp->e_xtype & XTYPE) == XUNDEF)
258: yywarning("%s: destination label is external",
259: FETCHNAME(ITABFETCH(opcode)));
260: if (!ISBYTE(argtype))
261: yyerror("%s: Branch too far(%db): try -J flag",
262: FETCHNAME(ITABFETCH(opcode)),
263: argtype);
264: break;
265: }
266: if (argtype == A_BW) {
267: ap->a_areg1 = argtype = xp->e_xvalue
268: -= dotp->e_xvalue + 2;
269: if ((xp->e_xtype & XTYPE) == XUNDEF)
270: yywarning("%s: destination label is external",
271: FETCHNAME(ITABFETCH(opcode)));
272: xp->e_xtype = XABS;
273: if (!ISWORD(argtype))
274: yyerror("%s: Branch too far(%db): try -J flag",
275: FETCHNAME(ITABFETCH(opcode)),
276: argtype);
277: xp->e_xvalue = argtype>>8;
278: reloc_how = TYPB;
279: break;
280: }
281: /* reduces to expr(pc) mode */
282: ap->a_areg1 |= (0xAF + mod124[ap->a_dispsize]);
283: reloc_how = type_124[ap->a_dispsize] + RELOC_PCREL;
284: break;
285:
286: case ADISP: /* expr(%r) */
287: ap->a_areg1 |= 0xA0;
288: if ((xp->e_xtype&XTYPE)!=XABS || xp->e_xtype&XFORW){
289: ap->a_areg1 += mod124[ap->a_dispsize];
290: reloc_how = type_124[ap->a_dispsize];
291: break;
292: }
293: if (xp->e_xvalue==0 && !(ap->a_areg1&0x10)) {
294: ap->a_areg1 ^= 0xC0;
295: break;
296: }
297: reloc_how = TYPB;
298: if (ISBYTE(xp->e_xvalue))
299: break;
300: ap->a_areg1 += 0x20;
301: reloc_how = TYPW;
302: if (ISWORD(xp->e_xvalue))
303: break;
304: ap->a_areg1 += 0x20;
305: reloc_how = TYPL;
306: break;
307:
308: case AIMM: /* $expr */
309: if (ap->a_atype&ASTAR) {
310: argtype=TYPL;
311: } else {
312: argtype = fetcharg(ITABFETCH(opcode), i);
313: if (argtype&ACCA)
314: argtype = TYPL;
315: else
316: argtype &= TYPMASK;
317: if (immconstant(xp, argtype, &value)){
318: reloc_how = TYPNONE;
319: ap->a_areg1 = value;
320: break;
321: }
322: }
323: ap->a_areg1 |= 0x8F;
324: reloc_how = argtype;
325: break;
326:
327: } /*end of the switch on argtype*/
328: /*
329: * use the first byte to describe the argument
330: */
331: Outb(ap->a_areg1);
332: if (reloc_how != TYPNONE)
333: outrel(xp, reloc_how);
334: } /*end of the for to pick up all arguments*/
335: }
336: /*
337: * Is xp an immediate constant?
338: * argtype: how the instruction will interpret the bytes
339: * xp->e_number.num_tag ("numtype"): the kind of number given
340: *
341: * Use the following table:
342: * float: TYPF, TYPD, TYPG, TYPH
343: * quad: TYPQ, TYPO
344: * int: TYPG, TYPW, TYPL
345: *
346: * numtype
347: * argtype float quad int
348: *
349: * float slitflt slitflt slitflt
350: * quad 0 0 0
351: * int 0..63 0 0..63
352: *
353: * Where the table entry implies the predicate to return.
354: */
355: #define IMMFLT 1 /* these flags are not used by anybody (yet) */
356: #define IMMINT 2
357:
358: int immconstant(xp, argtype, valuep)
359: reg struct exp *xp;
360: int argtype;
361: int *valuep;
362: {
363: reg int back = 0;
364: int numtype;
365: reg int fits;
366:
367: if ((xp->e_xtype & XTYPE) != XABS)
368: return(0);
369: if ((xp->e_xtype & XFORW) != 0)
370: return(0);
371: numtype = xp->e_number.num_tag;
372:
373: fits = 1;
374: if (passno == 2) switch(argtype){
375: case TYPB:
376: switch(numtype){
377: default: fits = 0; break;
378: case TYPB: fits = 1; break;
379: case TYPW:
380: case TYPL:
381: fits = ISBYTE(xp->e_xvalue) || ISUBYTE(xp->e_xvalue);
382: break;
383: }
384: break;
385: case TYPW:
386: switch(numtype){
387: default: fits = 0; break;
388: case TYPB:
389: case TYPW: fits = 1; break;
390: case TYPL:
391: fits = ISWORD(xp->e_xvalue) || ISUWORD(xp->e_xvalue);
392: break;
393: }
394: break;
395: case TYPF:
396: if (numtype == TYPD){ /* same format for first 32 bits */
397: fits = 1;
398: break;
399: }
400: /*FALLTHROUGH*/
401: default:
402: fits = ty_nbyte[argtype] >= ty_nbyte[numtype];
403: }
404: if (!fits){
405: yywarning("Immediate constant type %s mismatches instruction type %s",
406: ty_string[numtype],
407: ty_string[argtype]);
408: }
409:
410: switch(argtype){
411: case TYPF:
412: case TYPG:
413: case TYPD:
414: case TYPH:
415: back = slitflt(xp->e_number, argtype, valuep);
416: break;
417: case TYPO:
418: case TYPQ:
419: back = 0;
420: break;
421: case TYPB:
422: case TYPW:
423: case TYPL:
424: switch(numtype){
425: case TYPO:
426: case TYPQ:
427: back = 0;
428: break;
429: default:
430: *valuep = xp->e_xvalue;
431: back = ISLIT(xp->e_xvalue);
432: break;
433: }
434: break;
435: }
436: return(back);
437: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.