![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stin CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax|
Return to stin CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax |
1.1 ! root 1: SHAPES ! 2: # basic shapes ! 3: F: 'FREE'; ! 4: N: 'NAME' :2; ! 5: T: 'TEMP' :1; ! 6: A: 'AUTO' :1; ! 7: P: 'PARAM' :1; ! 8: CC: 'CC'; ! 9: R: 'REG':0; ! 10: ! 11: # constants ! 12: C: :4; ! 13: Cna: NONAME :4; ! 14: C0: CONVAL 0 :0; ! 15: C1: CONVAL 1 :0; ! 16: C2: CONVAL 2 :0; ! 17: C3: CONVAL 3 :0; ! 18: C4: CONVAL 4 :0; ! 19: C8: CONVAL 8 :0; ! 20: ! 21: CR: C, R; ! 22: ! 23: # more complicated address modes ! 24: ! 25: SOREG: *(R+C):1, *R:1 , *(R-Cna) :1; ! 26: AWD: SOREG,R,T,N,C,P,A; ! 27: # indirect addresses ! 28: INDIR: *N:3, *T:3, *SOREG:3, *P:3, *A:3; ! 29: IAWD: AWD, INDIR; ! 30: # char addresses, short addresses, long addresses, double addresses ! 31: # (auto decrement, auto increment, indexed, double index, and IAWD) ! 32: CADRS: R + AWD; ! 33: SADRS: ((R<<C1) + AWD), ('UAND'(AWD))+(R<<C1); ! 34: LADRS: ((R<<C2) + AWD), ('UAND'(AWD))+(R<<C2); ! 35: DADRS: ((R<<C3) + AWD), ('UAND'(AWD))+(R<<C3); ! 36: CAWD: *(R -= C1), *(R ++ C1), *( R + AWD ), IAWD ; ! 37: SAWD: *(R -= C2), *(R ++ C2), *((R<<C1)+AWD), *(('UAND'(AWD))+(R<<C1)), IAWD ; ! 38: LAWD: *(R -= C4), *(R ++ C4), *((R<<C2)+AWD), *(('UAND'(AWD))+(R<<C2)), IAWD ; ! 39: DAWD: *(R -= C8), *(R ++ C8), *((R<<C3)+AWD), *(('UAND'(AWD))+(R<<C3)), IAWD ; ! 40: SFLD: 'FLD' IAWD; ! 41: SCC: 'CONV' CAWD[c]; ! 42: SCUC: 'CONV' CAWD[uc]; ! 43: SCCUC: SCC, SCUC; ! 44: SCS: 'CONV' SAWD[s]; ! 45: SCUS: 'CONV' SAWD[us]; ! 46: SCSUS: SCS, SCUS; ! 47: SFLT: 'CONV' LAWD[f], LAWD[f]; ! 48: CDAWD: 'CONV' DAWD[d], DAWD[d]; ! 49: ! 50: OPCODES ! 51: # default cost - can we make costing more accurate? ! 52: # current method: add 1 for each opcode and 1 for each operand ! 53: DCOST :3; ! 54: ! 55: C0 {$N} "":0; ! 56: ! 57: 'COMOP' F,F {$N} "" ; ! 58: 'COMOP' F,R {$R $A $>} "Y" ; ! 59: 'COMOP' F,CC {$C $A} "" ; ! 60: ! 61: 'GENLAB' F {$N} "\\LL:\n" ; ! 62: 'GENLAB' R {$L} "\\LL:\n" ; ! 63: 'GENLAB' CC {$C} "\\LL:\n" ; ! 64: ! 65: 'GENUBR' F {$N} "ZI" ; ! 66: 'GENUBR' C {$N} "ZI" ; ! 67: 'GENUBR' R {$N} "ZI" ; ! 68: 'GENBR' CC {$N} "ZI" ; ! 69: ! 70: 'CM' F,F {$N} ""; ! 71: ! 72: 'CALL' C,F {$A $< $1} " calls Zc,CL\n" ; ! 73: 'CALL' R,F {$A $< $1} " calls Zc,(AL)\n" ; ! 74: ! 75: 'UCALL' C {$A $1} " calls $0,CL\n" ; ! 76: 'UCALL' R {$A $< $1} " calls $0,(AL)\n" ; ! 77: ! 78: = LAWD[p], CADRS {$L} " movab ZM,AL\n" ; ! 79: = LAWD[p], SADRS {$L} " movaw ZM,AL\n" ; ! 80: = LAWD[p], LADRS {$L} " moval ZM,AL\n" ; ! 81: = LAWD[p], DADRS {$L} " movad ZM,AL\n" ; ! 82: ! 83: = CAWD[cuc], C0 {$R} " clrb AL\n" :2; ! 84: = CAWD[cuc], C0 {$L} " clrb AL\n" :2; ! 85: = CAWD[cuc], CR {$L} "RL!R movb AR,AL\n" ; ! 86: = CAWD[cuc], CR {$R $C} " movb AR,AL\n" ; ! 87: = CAWD[cuc], CAWD[cuc] {$L} " movb AR,AL\n" ; ! 88: = CAWD[cuc], CAWD[cuc] {$R $C} " movb AR,AL\n" ; ! 89: ! 90: = SAWD[sus], C0 {$R} " clrw AL\n" :2; ! 91: = SAWD[sus], C0 {$L} " clrw AL\n" :2; ! 92: = SAWD[sus], SCC {$L $C} " cvtbw AR,AL\n" ; ! 93: = SAWD[sus], SCUC {$L $C} " movzbw AR,AL\n" ; ! 94: = SAWD[sus], CR {$L} "RL!R movw AR,AL\n" ; ! 95: = SAWD[sus], CR {$R $C} " movw AR,AL\n" ; ! 96: = SAWD[sus], SAWD[sus] {$L} " movw AR,AL\n" ; ! 97: = SAWD[sus], SAWD[sus] {$R $C} " movw AR,AL\n" ; ! 98: ! 99: = LAWD[iuip], SCC {$L $C} " cvtbl AR,AL\n" ; ! 100: = LAWD[iuip], SCUC {$L $C} " movzbl AR,AL\n" ; ! 101: = LAWD[iuip], SCS {$L $C} " cvtwl AR,AL\n" ; ! 102: = LAWD[iuip], SCUS {$L $C} " movzwl AR,AL\n" ; ! 103: = LAWD[iuip], C0 {$R} " clrl AL\n" ; ! 104: = LAWD[iuip], C0 {$L} " clrl AL\n" ; ! 105: = LAWD[iuip], CR {$L} "RL!R movl AR,AL\n" ; ! 106: = LAWD[iuip], CR {$R $C} " movl AR,AL\n" ; ! 107: = LAWD[iuip], LAWD[iuip] {$L} "RL!R movl AR,AL\n" ; ! 108: = LAWD[iuip], LAWD[iuip] {$R $C} " movl AR,AL\n" ; ! 109: ! 110: = SFLD[], LAWD[] { $R } " insv AR,$HL,$SL,AL\n" :5; ! 111: = LAWD[isc], SFLD[] {$L} " extv $HR,$SR,AR,AL\n" :5; ! 112: = LAWD[uiusuc], SFLD[] {$L} " extzv $HR,$SR,AR,AL\n" :5; ! 113: ! 114: C0[iuisuspcuc] {$1} " clrl A1\n" :2; ! 115: ! 116: # why not AL ?? ! 117: CAWD[cuc] {$C} " tstb AR\n" :2; ! 118: SAWD[sus] {$C} " tstw AR\n" :2; ! 119: LAWD[iuip] {$C} " tstl AR\n" :2; ! 120: LAWD[f] {$C} " tstf AR\n" :2; ! 121: DAWD[d] {$C} " tstd AR\n" :2; ! 122: CAWD[cuc] {$> $1} "RR!1 movb AR,A1\n" :3; ! 123: CAWD[cuc] {$> $1 $C} " movb AR,A1\n" :3; ! 124: SAWD[sus] {$> $1} "RR!1 movw AR,A1\n" :3; ! 125: SAWD[sus] {$> $1 $C} " movw AR,A1\n" :3; ! 126: LAWD[iuip] {$> $1} "RR!1 movl AR,A1\n" :3; ! 127: LAWD[iuip] {$> $1 $C} " movl AR,A1\n" :3; ! 128: LAWD[f] {$> $1} " movf AR,A1\n" :3; ! 129: LAWD[f] {$> $1 $C} "RR!1 movf AR,A1\n" :3; ! 130: DAWD[d] {$> $P $1} " movd AR,A1\n" :3; ! 131: DAWD[d] {$> $P $1 $C} "RR!1 movd AR,A1\n" :3; ! 132: ! 133: 'FLD' IAWD[isc] {$< $1} " extv $H.,$S.,AL,A1\n" :5; ! 134: 'FLD' IAWD[uiusuc] {$< $1} " extzv $H.,$S.,AL,A1\n" :5; ! 135: ! 136: 'ARG' LAWD[iuip] {$N} " pushl AL\n" :2; ! 137: 'ARG' C {$N} " pushl AL\n" :2; ! 138: 'ARG' SCS {$N} " cvtwl AL,-(sp)\n" ; ! 139: 'ARG' SCC {$N} " cvtbl AL,-(sp)\n" ; ! 140: 'ARG' SCUS {$N} " movzwl AL,-(sp)\n" ; ! 141: 'ARG' SCUC {$N} " movzbl AL,-(sp)\n" ; ! 142: 'ARG' LAWD[f] " cvtfd AL,-(sp)\n" ; ! 143: 'ARG' DAWD[d] " movd AL,-(sp)\n" ; ! 144: ! 145: # comparison opcodes ! 146: # "complex" comparisons - circumvent CONV nodes ! 147: # these phantom conversions should be removed in optim(), where allowed ! 148: #'CMP' SCCUC, Cuc[iui] {$C} " cmpb AL,AR\n" ; ! 149: #'CMP' SCCUC, R {$C} " cmpb AL,AR\n" ; ! 150: ! 151: 'CMP' CAWD[cuc], CAWD[cuc] {$C} " cmpb AL,AR\n" ; ! 152: #risky--used to be Cus on rhs ! 153: 'CMP' SAWD[sus], C {$C} " cmpw AL,AR\n" ; ! 154: 'CMP' SAWD[sus], R {$C} " cmpw AL,AR\n" ; ! 155: 'CMP' SAWD[sus], SAWD[sus] {$C} " cmpw AL,AR\n" ; ! 156: 'CMP' SFLT, SFLT {$C} " cmpf AL,AR\n" ; ! 157: ! 158: # "simple" comparisons - actually appear in tree ! 159: 'CMP' LAWD[iuip], LAWD[iuip] {$C} " cmpl AL,AR\n" ; ! 160: 'CMP' DAWD[d], DAWD[d] {$C} " cmpd AL,AR\n" ; ! 161: ! 162: # unary minus ! 163: 'UMINUS' LAWD[iuip] {$< $1} " mnegl AL,A1\n" ; ! 164: 'UMINUS' DAWD[d] {$P $< $1} " mnegd AL,A1\n" ; ! 165: ! 166: # compute addresses of automatics and parameters ! 167: 'UAND' A {$1} " moval AL,A1\n" ; ! 168: 'UAND' P {$1} " moval AL,A1\n" ; ! 169: 'UAND' T {$1} " moval AL,A1\n" ; ! 170: ! 171: # second operand of ++ and -- is the constant to be added or subtracted ! 172: # could play some games here with condition codes, since I think that ! 173: # inc doesn't change them... ! 174: ++ CAWD[c], C1 {$1} "F cvtbl A-L,A1\n incb AL\n" :2; ! 175: ++ CAWD[uc], C1 {$1} "F movzbl A-L,A1\n incb AL\n" :2; ! 176: ++ CAWD[c], C {$1} "F cvtbl A-L,A1\n addb2 AR,AL\n" ; ! 177: ++ CAWD[uc], C {$1} "F movzbl A-L,A1\n addb2 AR,AL\n" ; ! 178: ++ SAWD[s], C1 {$1} "F cvtwl A-L,A1\n incw AL\n" :2; ! 179: ++ SAWD[us], C1 {$1} "F movzwl A-L,A1\n incw AL\n" :2; ! 180: ++ SAWD[s], C {$1} "F cvtwl A-L,A1\n addw2 AR,AL\n" ; ! 181: ++ SAWD[us], C {$1} "F movzwl A-L,A1\n addw2 AR,AL\n" ; ! 182: ++ LAWD[iuip], C1 {$1} "F movl A-L,A1\n incl AL\n" ; ! 183: ++ LAWD[iuip], C {$1} "F movl A-L,A1\n addl2 AR,AL\n" ; ! 184: ! 185: -- CAWD[c], C1 {$1} "F cvtbl A-L,A1\n decb AL\n" :2; ! 186: -- CAWD[uc], C1 {$1} "F movzbl A-L,A1\n decb AL\n" :2; ! 187: -- CAWD[c], C {$1} "F cvtbl A-L,A1\n subb2 AR,AL\n" ; ! 188: -- CAWD[uc], C {$1} "F movzbl A-L,A1\n subb2 AR,AL\n" ; ! 189: -- SAWD[s], C1 {$1} "F cvtwl A-L,A1\n decw AL\n" :2; ! 190: -- SAWD[us], C1 {$1} "F movzwl A-L,A1\n decw AL\n" :2; ! 191: -- SAWD[s], C {$1} "F cvtwl A-L,A1\n subw2 AR,AL\n" ; ! 192: -- SAWD[us], C {$1} "F movzwl A-L,A1\n subw2 AR,AL\n" ; ! 193: -- LAWD[iuip], C1 {$1} "F movl A-L,A1\n decl AL\n" :2; ! 194: -- LAWD[iuip], C {$1} "F movl A-L,A1\n subl2 AR,AL\n" ; ! 195: ! 196: # & SAWD[susp], C {$C} " bit AL,AR\n" ; ! 197: # * R[susp], SAWD[susp] {$< $> $2} "RL!1RL!2\tmov\tAL,A2\nRL!1\tmul\tAR,A2\nRL=1\tmul\tAR,AL\n" ; ! 198: # % SAWD[susp], SAWD[susp] {$< $2} "RL!2 mov\tAL,r1\nZV\tdiv\tAR,r0\n" ; ! 199: # / SAWD[susp], SAWD[susp] {$< 2 $1} "RL!2\tmov\tAL,r1\nZV\tdiv\tAR,r0\n" ; ! 200: ! 201: += CAWD[cuc], C1 {$L $C} " incb AL\n" :2; ! 202: += SAWD[sus], C1 {$L $C} " incw AL\n" :2; ! 203: += LAWD[iuip], C1 {$L $C} " incl AL\n" :2; ! 204: += LAWD[iuip], LAWD[iuip] {$L $C} " addl2 AR,AL\n" ; ! 205: ! 206: -= CAWD[cuc], C1 {$L $C} " decb AL\n" :2; ! 207: -= SAWD[sus], C1 {$L $C} " decw AL\n" :2; ! 208: -= LAWD[iuip], C1 {$L $C} " decl AL\n" :2; ! 209: -= LAWD[iuip], LAWD[iuip] {$L $C} " subl2 AR,AL\n" ; ! 210: ! 211: |= LAWD[iuip], LAWD[iuip] {$L $C} " bisl2 AR,AL\n" ; ! 212: ! 213: &= LAWD[iuip], Cna {$L $C} " bicl2 Zk,AL\n" ; ! 214: &= LAWD[iuip], LAWD[iuip] {$L 1 $C} " mcoml AR,A1\n bicl2 A1,AL\n" :6; ! 215: ! 216: ^= LAWD[iuip], LAWD[iuip] {$L $C} " xorl2 AR,AL\n" ; ! 217: ! 218: # right operand must be CAWD due to VAX operand typing ! 219: <<= LAWD[iuip], CAWD[iuip] " ashl AR,A-L,AL\n" ; ! 220: << LAWD[iuip], CAWD[iuip] {$1 $> $<} " ashl AR,AL,A1\n" ; ! 221: ! 222: >>= LAWD[i], LAWD[iuip] {$L 1 $>} " mnegl AR,A1\n ashl A1,A-L,AL\n" :7; ! 223: >> LAWD[i], LAWD[iuip] {$1 $>} " mnegl AR,A1\n ashl A1,AL,A1\n" :7; ! 224: # left operand must be IAWD due to VAX operand typing ! 225: >>= IAWD[i], C {$L} " extv AR,ZU,A-L,AL\n" :5; ! 226: >> IAWD[i], C {$1 $>} " extv AR,ZU,AL,A1\n" :5; ! 227: ! 228: >>= IAWD[uip],CAWD[iuip] {$L 1 $C}"\tsubl3\tA-R,$32,A1\n\textzv\tAR,A1,A-L,AL\n":9; ! 229: >> IAWD[uip], CAWD[iuip] {$1 $C} "\tsubl3\tA-R,$32,A1\n\textzv\tAR,A1,AL,A1\n":9; ! 230: >>= IAWD[uip], C {$L} " extzv AR,ZU,A-L,AL\n" :5; ! 231: >> IAWD[uip], C {$1 $>} " extzv AR,ZU,AL,A1\n" :5; ! 232: ! 233: # convert characters to other types ! 234: 'CONV' [sus] CAWD[uc] {$< $1 $C} " movzbw AL,A1\n" ; ! 235: 'CONV' [iuip] CAWD[uc] {$< $1 $C} " movzbl AL,A1\n" ; ! 236: 'CONV' [sus] CAWD[c] {$< $1 $C} " cvtbw AL,A1\n" ; ! 237: 'CONV' [iuip] CAWD[c] {$< $1 $C} " cvtbl AL,A1\n" ; ! 238: 'CONV' [f] CAWD[uc] {$< $1 $C} "\tmovzbl\tAL,A1\n\tcvtlf\tA1,A1\n" :6; ! 239: 'CONV' [d] CAWD[uc] {$< $P $1 $C} "\tmovzbl\tAL,A1\n\tcvtld\tA1,A1\n" :6; ! 240: 'CONV' [f] CAWD[c] {$< $1 $C} " cvtbf AL,A1\n" ; ! 241: 'CONV' [d] CAWD[c] {$< $P $1 $C} " cvtbd AL,A1\n" ; ! 242: ! 243: # convert short to other types ! 244: 'CONV' [cuc] SAWD[sus] {$< $1} "RL!1 movw AL,A1\n" ; ! 245: 'CONV' [cuc] SAWD[sus] {$< $1 $C} " movw AL,A1\n" ; ! 246: 'CONV' [iuip] SAWD[s] {$< $1 $C} " cvtwl AL,A1\n" ; ! 247: 'CONV' [iuip] SAWD[us] {$< $1 $C} " movzwl AL,A1\n" ; ! 248: 'CONV' [f] SAWD[us] {$< $1 $C} "\tmovzwl\tAL,A1\n\tcvtlf\tA1,A1\n" :6; ! 249: 'CONV' [d] SAWD[us] {$< $P $1 $C} "\tmovzwl\tAL,A1\n\tcvtld\tA1,A1\n" :6; ! 250: 'CONV' [f] SAWD[s] {$< $1 $C} " cvtwf AL,A1\n" ; ! 251: 'CONV' [d] SAWD[s] {$< $P $1 $C} " cvtwd AL,A1\n" ; ! 252: ! 253: # convert integer (long values) to other types ! 254: 'CONV' [cucsusiuip] LAWD[iuip] {$< $1} "RL!1 movl AL,A1\n" ; ! 255: 'CONV' [cucsusiuip] LAWD[iuip] {$< $1 $C} " movl AL,A1\n" ; ! 256: #?? need conversion for unsigned to [fd]. cvtl_ won't work correctly ! 257: #use cvtl_ for unsigned for now ! 258: 'CONV' [f] LAWD[iuip] {$< $1 $C} " cvtlf AL,A1\n" ; ! 259: 'CONV' [d] LAWD[iuip] {$< $1 $P $C} " cvtld AL,A1\n" ; ! 260: ! 261: # convert floating to other types ! 262: 'CONV' [cuc] LAWD[f] {$< $1 $C} " cvtfb AL,A1\n" ; ! 263: 'CONV' [sus] LAWD[f] {$< $1 $C} " cvtfw AL,A1\n" ; ! 264: 'CONV' [iuip] LAWD[f] {$< $1 $C} " cvtfl AL,A1\n" ; ! 265: 'CONV' [d] LAWD[f] {$< $1 $P $C} " cvtfd AL,A1\n" ; ! 266: ! 267: # convert double to other types ! 268: 'CONV' [cuc] DAWD[d] {$< $1 $C} " cvtdb AL,A1\n" ; ! 269: 'CONV' [sus] DAWD[d] {$< $1 $C} " cvtdw AL,A1\n" ; ! 270: 'CONV' [iuip] DAWD[d] {$< $1 $C} " cvtdl AL,A1\n" ; ! 271: 'CONV' [f] DAWD[d] {$< $1 $C} " cvtdf AL,A1\n" ; ! 272: ! 273: ! 274: # structure manipulation ! 275: # movc3 blows regs r0 - r5, so ask for all temps ! 276: 'STARG' AWD {$A $< $> $N} " subl2 ZT,sp\nZS" ; ! 277: 'STASG' AWD, AWD {$A $> $L} "ZS" ; ! 278: ! 279: 'INIT' [cuc] C {$N} " .byte CL\n" ; ! 280: 'INIT' [sus] C {$N} " .word CL\n" ; ! 281: 'INIT' [iuip] C {$N} " .long CL\n" ; ! 282: ! 283: = DAWD[d], DAWD[d] {$L} "RL!R movd AR,AL\n" ; ! 284: = DAWD[d], DAWD[d] {$R $C} " movd AR,AL\n" ; ! 285: = LAWD[f], LAWD[f] {$R} " movl AR,AL\n" ; ! 286: = LAWD[f], LAWD[f] {$C} " movf AR,AL\n" ; ! 287: = LAWD[f], CDAWD {$R $C} " cvtdf AR,AL\n" ; ! 288: ! 289: # integer opcodes ! 290: # how about two-address opcodes, such as ! 291: # + LAWD[ip], R[ip] {$R} " addl2 AL,AR\n" ; ! 292: # is someone smart enough to commute this if necessary?? ! 293: + LAWD[iuip], LAWD[iuip] {$1 $< $>} " addl3 AL,AR,A1\n" :4; ! 294: - LAWD[iuip], LAWD[iuip] {$1 $< $>} " subl3 AR,AL,A1\n" :4; ! 295: * LAWD[iuip], LAWD[iuip] {$< $> $1} " mull3 AR,AL,A1\n" :4; ! 296: / LAWD[ip], LAWD[ip] {$< $> $1} " divl3 AR,AL,A1\n" :4; ! 297: / LAWD[iui], LAWD[iui] {$A $1 $<} "\tpushl\tAR\n\tpushl\tAL\n\tcalls\t$2,udiv\n" :11; ! 298: ~ LAWD[iuip] {$1 $< $C} " mcoml AL,A1\n" ; ! 299: | LAWD[iuip], LAWD[iuip] {$1 $< $> $C} " bisl3 AR,AL,A1\n" :4; ! 300: & LAWD[iuip], LAWD[iuip] {$C} " bitl AR,AL\n" ; ! 301: # & LAWD[iuip], Cna {$C} " bitl AR,AL\n" ; ! 302: & LAWD[iuip], Cna {$1 $< $C} " bicl3 Zk,AL,A1\n" :4; ! 303: & LAWD[iuip], LAWD[iuip] {$1 $> $C} "\tmcoml AR,A1\n bicl3 A1,AL,A1\n" :7; ! 304: % LAWD[ip], LAWD[ip] {$C $1 1} "\tdivl3\tA-R,A-L,A1\n\tmull2\tAR,A1\n\tsubl3\tA1,AL,A1\n" :11; ! 305: % LAWD[iui], LAWD[iui] {$A $1 $< $>} "\tpushl\tAR\n\tpushl\tAL\n\tcalls\t$2,urem\n" :11; ! 306: # following 3 address ops not included to reduce number of templates ! 307: # = LAWD[iuip], ( LAWD[iuip] + LAWD[iuip] ) " addl3 A(RL),A(RR),AL\n" :4; ! 308: # = LAWD[iuip], ( LAWD[iuip] - LAWD[iuip] ) " subl3 A(RR),A(RL),AL\n" :4; ! 309: # = LAWD[iuip], ( LAWD[iuip] | LAWD[iuip] ) " bicl3 A(RL),A(RR),AL\n" :4; ! 310: ! 311: ! 312: # double opcodes ! 313: + DAWD[d], DAWD[d] {$< $> $P $1 $C} " addd3 AR,AL,A1\n" :4; ! 314: - DAWD[d], DAWD[d] {$< $> $P $1 $C} " subd3 AR,AL,A1\n" :4; ! 315: * DAWD[d], DAWD[d] {$< $> $P $1 $C} " muld3 AR,AL,A1\n" :4; ! 316: / DAWD[d], DAWD[d] {$< $> $P $1 $C} " divd3 AR,AL,A1\n" :4; ! 317: ! 318: # double assignment opcodes ! 319: += DAWD[d], DAWD[d] {$L $C} " addd2 AR,AL\n" ; ! 320: -= DAWD[d], DAWD[d] {$L $C} " subd2 AR,AL\n" ; ! 321: *= DAWD[d], DAWD[d] {$L $C} " muld2 AR,AL\n" ; ! 322: /= DAWD[d], DAWD[d] {$L $C} " divd2 AR,AL\n" ; ! 323: ! 324: # float opcodes ! 325: + LAWD[f], LAWD[f] {$< $> $1 $C} " addf3 AR,AL,A1\n":3; ! 326: - LAWD[f], LAWD[f] {$< $> $1 $C} " subf3 AR,AL,A1\n":3; ! 327: * LAWD[f], LAWD[f] {$< $> $1 $C} " mulf3 AR,AL,A1\n":3; ! 328: / LAWD[f], LAWD[f] {$< $> $1 $C} " divf3 AR,AL,A1\n":3; ! 329: ! 330: # float assignment opcodes ! 331: += LAWD[f], LAWD[f] {$L $C} " addf2 AR,AL\n"; ! 332: -= LAWD[f], LAWD[f] {$L $C} " subf2 AR,AL\n"; ! 333: *= LAWD[f], LAWD[f] {$L $C} " mulf2 AR,AL\n"; ! 334: /= LAWD[f], LAWD[f] {$L $C} " divf2 AR,AL\n"; ! 335: ! 336: # for the use of fortran only ! 337: ! 338: # 'GOTO' C {$N} " jbr CL\n" ; ! 339: # 'GOTO' N[iui] {$N} " jmp *UL\n" ; ! 340: # 'GOTO' N[suscucp] {$N} " jmp *AL\n" ;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.