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