![[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.