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