![[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] / 3BSD / cmd / as|
Return to ascode.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / as |
1.1 ! root 1: /* Copyright (c) 1979 Regents of the University of California */ ! 2: #include <stdio.h> ! 3: #include "as.h" ! 4: #include "assyms.h" ! 5: ! 6: insout(op, ap, nact) ! 7: struct arg *ap; ! 8: { ! 9: int jxxflg; ! 10: ! 11: op &= 0xFF; ! 12: jxxflg = nact; ! 13: if (nact < 0) ! 14: nact = -nact; ! 15: if (passno!=2) { ! 16: register struct arg *ap2; ! 17: register struct instab *ip; ! 18: int i,nexp; ! 19: ip = itab[op]; ! 20: nexp = ip->nargs; ! 21: if (nact < nexp) ! 22: yyerror("Too few arguments"); ! 23: if (nact > nexp) { ! 24: yyerror("Too many arguments"); ! 25: nact = nexp; ! 26: } ! 27: /* ! 28: * Check argument compatability with instruction template ! 29: */ ! 30: for (ap2 = ap+nact, i = nact; --i >= 0;) ! 31: argcompat(--ap2, ip->argtype[i], i); ! 32: } ! 33: if (jxxflg < 0) ! 34: ijxout(op, ap, nact); ! 35: else putins(op, ap, nact); ! 36: } ! 37: ! 38: argcompat(act, exp, i) ! 39: struct arg *act; ! 40: int exp,i; ! 41: { ! 42: register at,atm; ! 43: ! 44: at = act->atype; ! 45: atm = at & AMASK; ! 46: ! 47: if ((exp & ACCA) && (atm == AREG)) { ! 48: yyerror("arg %d, addressing a register",i); ! 49: return; ! 50: } ! 51: if ((exp&ACCW) && (atm==AIMM) && !(at&ASTAR)) { ! 52: yyerror("arg %d, modifying a constant",i); ! 53: return; ! 54: } ! 55: if (at & AINDX) { ! 56: if (act->areg2==017) { ! 57: yyerror("arg %d, PC used as index",i); ! 58: return; ! 59: } ! 60: if (atm==AREG) { ! 61: yyerror("arg %d, indexing the register file",i); ! 62: return; ! 63: } ! 64: if (atm==AIMM) { ! 65: yyerror("arg %d, indexing a constant",i); ! 66: return; ! 67: } ! 68: if (((atm==ADECR) || (atm==AINCR)) && (act->areg1==act->areg2)) { ! 69: yyerror("arg %d, indexing with modified register",i); ! 70: return; ! 71: } ! 72: } ! 73: } ! 74: ! 75: int d124 = {4}; ! 76: int len124[] = {0,LEN1,LEN2,0,LEN4}; ! 77: char mod124[] = {0,0x00,0x20,0,0x40}; ! 78: ! 79: putins(op, ap, n) ! 80: /* ! 81: * n had better be positive ! 82: */ ! 83: register struct arg *ap; ! 84: { ! 85: register struct exp *xp; ! 86: register int a; ! 87: int i,xtrab; ! 88: ! 89: if (passno!=2) { ! 90: dotp->xvalue += n+1; /* 1 for the opcode, at least 1 per arg */ ! 91: for (i=0; i<n; i++,ap++) {/* some args take more than 1 byte */ ! 92: a=ap->atype; ! 93: if (a & AINDX) ! 94: dotp->xvalue++; ! 95: switch (a&~(AINDX|ASTAR)) { ! 96: case AEXP: { ! 97: a = itab[op]->argtype[i]; ! 98: if (a == ACCB+TYPB) ! 99: break; ! 100: if (a==ACCB+TYPW){ ! 101: dotp->xvalue++; ! 102: break; ! 103: } ! 104: dotp->xvalue += ap->dispsize; ! 105: break; ! 106: } ! 107: case ADISP: { ! 108: xp=ap->xp; ! 109: if ((xp->xtype&XTYPE)!=XABS || xp->xtype&XFORW){ ! 110: dotp->xvalue += ap->dispsize; ! 111: break; ! 112: } ! 113: if (xp->xvalue==0 && !(a&ASTAR)) ! 114: break; ! 115: dotp->xvalue++; ! 116: if ((xp->xvalue<MINBYTE) || (xp->xvalue>MAXBYTE)) ! 117: dotp->xvalue++; ! 118: if ((xp->xvalue<MINWORD) || (xp->xvalue>MAXWORD)) ! 119: dotp->xvalue += 2; ! 120: break; ! 121: } ! 122: case AIMM: { ! 123: if (ap->atype&ASTAR) a=TYPL; ! 124: else { ! 125: xp = ap->xp; ! 126: if ((xp->xtype&XTYPE)==XABS && !(xp->xtype&XFORW) ! 127: && xp->xvalue>=0 && xp->xvalue<=63) ! 128: break; ! 129: a = itab[op]->argtype[i]; ! 130: if (a&ACCA) ! 131: a = TYPL; ! 132: else ! 133: a &= TYPMASK; ! 134: } ! 135: switch (a) { ! 136: case TYPD: ! 137: case TYPF: ! 138: if (slitflt(xp)) ! 139: break; ! 140: if (a==TYPF) ! 141: dotp->xvalue -= 4; ! 142: case TYPQ: ! 143: dotp->xvalue += 4; ! 144: case TYPL: ! 145: dotp->xvalue += 2; ! 146: case TYPW: ! 147: dotp->xvalue++; ! 148: case TYPB: ! 149: dotp->xvalue++; ! 150: } /*end of the switch on a*/ ! 151: } /*end of case AIMM*/ ! 152: } /*end of the switch on the type*/ ! 153: } /*end of looping for all arguments*/ ! 154: return; ! 155: } /*end of it being time for pass 1*/ ! 156: /* ! 157: * PASS2 HERE ! 158: */ ! 159: ! 160: outb(op); /* the opcode */ ! 161: for (i=0; i<n; i++,ap++) {/* now for the arguments */ ! 162: a=ap->atype; ! 163: xp=ap->xp; ! 164: xtrab=0; ! 165: if (a&AINDX) { ! 166: { outb(0x40 | ap->areg2); } ! 167: a &= ~AINDX; ! 168: } ! 169: if (a&ASTAR) { ! 170: ap->areg1 |= 0x10; ! 171: a &= ~ASTAR; ! 172: } ! 173: switch (a) { ! 174: case AREG: /* %r */ ! 175: ap->areg1 |= 0x50; ! 176: break; ! 177: case ABASE: /* (%r) */ ! 178: ap->areg1 |= 0x60; ! 179: break; ! 180: case ADECR: /* -(%r) */ ! 181: ap->areg1 |= 0x70; ! 182: break; ! 183: case AINCR: /* (%r) */ ! 184: ap->areg1 |= 0x80; ! 185: break; ! 186: case AEXP: {/* expr */ ! 187: a = itab[op]->argtype[i]; ! 188: if (a == ACCB+TYPB) { ! 189: ap->areg1 = a = ! 190: xp->xvalue - (dotp->xvalue + 1); ! 191: if (a<MINBYTE || a>MAXBYTE) ! 192: yyerror("Branch too far"); break; ! 193: } ! 194: if (a == ACCB+TYPW) { ! 195: ap->areg1 = a = xp->xvalue ! 196: -= dotp->xvalue + 2; ! 197: xp->xtype = XABS; ! 198: if (a<MINWORD || a>MAXWORD) ! 199: yyerror("Branch too far"); ! 200: xp->xvalue = a>>8; ! 201: xtrab = LEN1; ! 202: break; ! 203: } ! 204: /* reduces to expr(pc) mode */ ! 205: ap->areg1 |= (0xAF + mod124[ap->dispsize]); ! 206: xtrab = len124[ap->dispsize]+PCREL; ! 207: break; ! 208: } ! 209: case ADISP: {/* expr(%r) */ ! 210: ap->areg1 |= 0xA0; ! 211: if ((xp->xtype&XTYPE)!=XABS || xp->xtype&XFORW){ ! 212: ap->areg1 += mod124[ap->dispsize]; ! 213: xtrab=len124[ap->dispsize]; ! 214: break; ! 215: } ! 216: if (xp->xvalue==0 && !(ap->areg1&0x10)) { ! 217: ap->areg1 ^= 0xC0; ! 218: break; ! 219: } ! 220: xtrab=LEN1; ! 221: if ((xp->xvalue<MINBYTE) || (xp->xvalue>MAXBYTE)){ ! 222: ap->areg1 += 0x20; ! 223: xtrab=LEN2; ! 224: } ! 225: if ((xp->xvalue<MINWORD) || (xp->xvalue>MAXWORD)){ ! 226: ap->areg1 += 0x20; ! 227: xtrab=LEN4; ! 228: } ! 229: break; ! 230: } ! 231: case AIMM: { /* $expr */ ! 232: if (ap->atype&ASTAR) ! 233: a=TYPL; ! 234: else { ! 235: if ( ( (xp->xtype&XTYPE) == XABS) ! 236: && !(xp->xtype&XFORW) ! 237: && (xp->xvalue >= 0) ! 238: && (xp->xvalue <= 63) ) { ! 239: ap->areg1 = xp->xvalue; ! 240: break; ! 241: } ! 242: a = itab[op]->argtype[i]; ! 243: if (a&ACCA) ! 244: a=TYPL; ! 245: else ! 246: a &= TYPMASK; ! 247: } ! 248: ap->areg1 |= 0x8F; ! 249: switch (a) { ! 250: case TYPD: ! 251: case TYPF: ! 252: if (slitflt(xp)){ ! 253: ap->areg1=extlitflt(xp); ! 254: break; ! 255: } ! 256: if (a==TYPF) { ! 257: xtrab = LEN4; ! 258: break; ! 259: } ! 260: case TYPQ: xtrab = LEN8; break; ! 261: case TYPL: xtrab = LEN4; break; ! 262: case TYPW: xtrab = LEN2; break; ! 263: case TYPB: xtrab = LEN1; break; ! 264: } ! 265: } /*end of the switch on AIMM*/ ! 266: } /*end of the switch on a*/ ! 267: /* ! 268: * use the first byte to describe the argument ! 269: */ ! 270: outb(ap->areg1); ! 271: if (xtrab) ! 272: outrel(&xp->xvalue, xtrab, xp->xtype, xp->xname); ! 273: } /*end of the for to pick up all arguments*/ ! 274: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.