![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe6.lst CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4|
Return to pipe6.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1: 1 00000000 LL0:
2: 2 00000000 .data
3: 3 00000db8 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_6
6: 6 00000000 _pipe_6:
7: 7 0002A0B4 0000 .word L215
8: 8 0002A0B6 # #include "fpp_defs.h"
9: 9 0002A0B6 #
10: 10 0002A0B6 #
11: 11 0002A0B6 # /*****************************************************************************
12: 12 0002A0B6 # *
13: 13 0002A0B6 # * PIPELINE TEST #6 MONITOR
14: 14 0002A0B6 # *
15: 15 0002A0B6 # * This test will do:
16: 16 0002A0B6 # *
17: 17 0002A0B6 # * LDF(0) ADDF(y) STF CVLF(x) SUBF(0) STF
18: 18 0002A0B6 # *
19: 19 0002A0B6 # * where x is the fmacro1 CVLF data, and y is the expected result of the CVLF.
20: 20 0002A0B6 # * This test verifies the CVLF after the STF and the SUBF after the CVLF.
21: 21 0002A0B6 # *****************************************************************************/
22: 22 0002A0B6 # pipe_6()
23: 23 0002A0B6 # {
24: 24 0002A0B6 13 00a8 jbr L217
25: 25 0002A0B9 L218:
26: 26 0002A0B9 # asm(".globl _pipeline_6_t");
27: 27 0002A0B9 .globl _pipeline_6_t
28: 28 0002A0B9 # asm("_pipeline_6_t:"); /* entry address */
29: 29 0002A0B9 _pipeline_6_t:
30: 30 0002A0B9 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
31: 31 0002A0B9 1d effffffff5 01 cmpl _cycle,$1
32: 32 0002A0C0 21 15 jneq L219
33: 33 0002A0C2 5d efffffffec tstl _prt_hdrs
34: 34 0002A0C8 31 0d jeql L219
35: 35 0002A0CA # {
36: 36 0002A0CA # writes(" PIPE_6 ");
37: 37 0002A0CA .data 1
38: 38 00000db8 * L221:
39: 39 00000db8 * 20504950455F362000 .ascii " PIPE_6 \0"
40: 40 00000dc1 * .text
41: 41 0002A0CA dd 8f00000db8 pushl $L221
42: 42 0002A0D0 fe 08 efffffffdd callf $8,_writes
43: 43 0002A0D7 # }
44: 44 0002A0D7 # subtest = 1;
45: 45 0002A0D7 L219:
46: 46 0002A0D7 0d 01 efffffffd6 movl $1,_subtest
47: 47 0002A0DE # pipe6_1(); /* data in REGs, no NOPs */
48: 48 0002A0DE fe 04 ef0000007f callf $4,_pipe6_1
49: 49 0002A0E5 # subtest++; /* increment subtest num */
50: 50 0002A0E5 6d efffffffc9 incl _subtest
51: 51 0002A0EB # pipe6_2(); /* data in REGs, 1 NOP */
52: 52 0002A0EB fe 04 ef0000016a callf $4,_pipe6_2
53: 53 0002A0F2 # subtest++; /* increment subtest num */
54: 54 0002A0F2 6d efffffffbc incl _subtest
55: 55 0002A0F8 # pipe6_3(); /* data in REGs, 2 NOPs */
56: 56 0002A0F8 fe 04 ef0000025b callf $4,_pipe6_3
57: 57 0002A0FF # subtest++; /* increment subtest num */
58: 58 0002A0FF 6d efffffffaf incl _subtest
59: 59 0002A105 # pipe6_4(); /* data in REGs, 3 NOPs */
60: 60 0002A105 fe 04 ef00000350 callf $4,_pipe6_4
61: 61 0002A10C # subtest++; /* increment subtest num */
62: 62 0002A10C 6d efffffffa2 incl _subtest
63: 63 0002A112 # pipe6_5(); /* data in CACHE, no NOPs */
64: 64 0002A112 fe 04 ef0000044b callf $4,_pipe6_5
65: 65 0002A119 # subtest++; /* increment subtest num */
66: 66 0002A119 6d efffffff95 incl _subtest
67: 67 0002A11F # pipe6_6(); /* data in CACHE, 1 NOP */
68: 68 0002A11F fe 04 ef0000052c callf $4,_pipe6_6
69: 69 0002A126 # subtest++; /* increment subtest num */
70: 70 0002A126 6d efffffff88 incl _subtest
71: 71 0002A12C # pipe6_7(); /* data in CACHE, 2 NOPs */
72: 72 0002A12C fe 04 ef00000611 callf $4,_pipe6_7
73: 73 0002A133 # subtest++; /* increment subtest num */
74: 74 0002A133 6d efffffff7b incl _subtest
75: 75 0002A139 # pipe6_8(); /* data in CACHE, 3 NOPs */
76: 76 0002A139 fe 04 ef000006fc callf $4,_pipe6_8
77: 77 0002A140 # subtest++; /* increment subtest num */
78: 78 0002A140 6d efffffff6e incl _subtest
79: 79 0002A146 # pipe6_9(); /* data on STACK, no NOPs */
80: 80 0002A146 fe 04 ef000007eb callf $4,_pipe6_9
81: 81 0002A14D # subtest++; /* increment subtest num */
82: 82 0002A14D 6d efffffff61 incl _subtest
83: 83 0002A153 # pipe6_10(); /* data via FP no NOPs */
84: 84 0002A153 fe 04 ef00000972 callf $4,_pipe6_10
85: 85 0002A15A # asm("jmp *return"); /* return to the test monitor */
86: 86 0002A15A 71 ffffffff54 jmp *return
87: 87 0002A160 # }
88: 88 0002A160 40 ret#2
89: 89 0002A161 .set L215,0x0
90: 90 0002A161 L217:
91: 91 0002A161 13 ff55 jbr L218
92: 92 0002A164 .data
93: 93 00000db8 * .text
94: 94 0002A164 .align 1
95: 95 0002A164 .globl _pipe6_1
96: 96 0002A164 _pipe6_1:
97: 97 0002A164 0000 .word L232
98: 98 0002A166 #
99: 99 0002A166 #
100: 100 0002A166 #
101: 101 0002A166 #
102: 102 0002A166 #
103: 103 0002A166 #
104: 104 0002A166 # /************************************************************************
105: 105 0002A166 # *
106: 106 0002A166 # * SUBTEST 1
107: 107 0002A166 # * data in registers, no NO-OPs
108: 108 0002A166 # *
109: 109 0002A166 # ************************************************************************/
110: 110 0002A166 # pipe6_1()
111: 111 0002A166 # {
112: 112 0002A166 13 00f0 jbr L234
113: 113 0002A169 L235:
114: 114 0002A169 # force_loop = FALSE; /* clear the force_loop flag */
115: 115 0002A169 4d efffffff45 clrl _force_loop
116: 116 0002A16F # index = 0;
117: 117 0002A16F 4d efffffff3f clrl _index
118: 118 0002A175 # do
119: 119 0002A175 L238:
120: 120 0002A175 # {
121: 121 0002A175 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
122: 122 0002A175 0d efffffff39 50 movl _index,r0
123: 123 0002A17C 48 03 50 50 shll $3,r0,r0
124: 124 0002A180 0d e000000000 efffffff29 movl _cvlf_1_data(r0),_sgl_value_1
125: 125 0002A18B # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
126: 126 0002A18B 0d efffffff23 50 movl _index,r0
127: 127 0002A192 48 03 50 50 shll $3,r0,r0
128: 128 0002A196 0d e000000004 efffffff13 movl _cvlf_1_data+4(r0),_sgl_expected
129: 129 0002A1A1 # sgl_value_2 = 0; /* floating '0' */
130: 130 0002A1A1 4d efffffff0d clrl _sgl_value_2
131: 131 0002A1A7 # /*
132: 132 0002A1A7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
133: 133 0002A1A7 # * The force loop flag is set after the first error.
134: 134 0002A1A7 # */
135: 135 0002A1A7 # asm("_pipe6_1_lp1:");
136: 136 0002A1A7 _pipe6_1_lp1:
137: 137 0002A1A7 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
138: 138 0002A1A7 0d efffffff07 54 movl _sgl_value_1,r4
139: 139 0002A1AE # asm("movl _sgl_value_2,r5"); /* move data to r5 */
140: 140 0002A1AE 0d efffffff00 55 movl _sgl_value_2,r5
141: 141 0002A1B5 # asm("movl _sgl_expected,r6"); /* save the expected result*/
142: 142 0002A1B5 0d effffffef9 56 movl _sgl_expected,r6
143: 143 0002A1BC # asm("ldf r5"); /* load a floating '0' */
144: 144 0002A1BC 06 55 ldf r5
145: 145 0002A1BE # asm("addf r6"); /* add the expected value */
146: 146 0002A1BE c6 56 addf r6
147: 147 0002A1C0 # asm("stf r7"); /* store the result */
148: 148 0002A1C0 26 57 stf r7
149: 149 0002A1C2 # asm("cvlf r4"); /* convert the operand */
150: 150 0002A1C2 76 54 cvlf r4
151: 151 0002A1C4 # asm("subf r5"); /* subtract a floating '0' */
152: 152 0002A1C4 d6 55 subf r5
153: 153 0002A1C6 # asm("stf r8"); /* store the result */
154: 154 0002A1C6 26 58 stf r8
155: 155 0002A1C8 # if( force_loop )
156: 156 0002A1C8 5d effffffee6 tstl _force_loop
157: 157 0002A1CE 31 02 jeql L239
158: 158 0002A1D0 # asm("brb _pipe6_1_lp1");; /* loop on the error */
159: 159 0002A1D0 11 d5 brb _pipe6_1_lp1
160: 160 0002A1D2 L239:
161: 161 0002A1D2 # /*
162: 162 0002A1D2 # * verify the results
163: 163 0002A1D2 # */
164: 164 0002A1D2 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
165: 165 0002A1D2 0d 57 effffffedb movl r7,_sgl_st_acc
166: 166 0002A1D9 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
167: 167 0002A1D9 0d 58 effffffed4 movl r8,_sgl_value_6
168: 168 0002A1E0 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
169: 169 0002A1E0 # (sgl_value_6 != sgl_expected) )
170: 170 0002A1E0 1d effffffece effffffec9 cmpl _sgl_st_acc,_sgl_expected
171: 171 0002A1EB 21 0d jneq L9999
172: 172 0002A1ED 1d effffffec1 effffffebc cmpl _sgl_value_6,_sgl_expected
173: 173 0002A1F8 31 45 jeql L240
174: 174 0002A1FA L9999:
175: 175 0002A1FA # {
176: 176 0002A1FA # errcnt++; /* bump the error count */
177: 177 0002A1FA 6d effffffeb4 incl _errcnt
178: 178 0002A200 # if ( prt_error )
179: 179 0002A200 5d effffffeae tstl _prt_error
180: 180 0002A206 31 0d jeql L241
181: 181 0002A208 # print_pipe6_er("Reg. Data, no NO-OPs");
182: 182 0002A208 .data 1
183: 183 00000dc1 * L243:
184: 184 00000dc1 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
185: F204E4F2D4F507300
186: 185 00000dd6 * .text
187: 186 0002A208 dd 8f00000dc1 pushl $L243
188: 187 0002A20E fe 08 ef00000a93 callf $8,_print_pipe6_er
189: 188 0002A215 # if ( halt_flg ) /* halt on error? */
190: 189 0002A215 L241:
191: 190 0002A215 5d effffffe99 tstl _halt_flg
192: 191 0002A21B 31 0d jeql L244
193: 192 0002A21D # pipe6_er_hlt( subtest );
194: 193 0002A21D dd effffffe91 pushl _subtest
195: 194 0002A223 fe 08 ef00000bc6 callf $8,_pipe6_er_hlt
196: 195 0002A22A # if ( loop_on_err ) {
197: 196 0002A22A L244:
198: 197 0002A22A 5d effffffe84 tstl _loop_on_err
199: 198 0002A230 31 0d jeql L246
200: 199 0002A232 # force_loop = TRUE; /* set the force loop flag */
201: 200 0002A232 0d 01 effffffe7b movl $1,_force_loop
202: 201 0002A239 # asm("jmp _pipe6_1_lp1"); /* and loop */
203: 202 0002A239 71 efffffff68 jmp _pipe6_1_lp1
204: 203 0002A23F # }
205: 204 0002A23F # } /* end of compare error */
206: 205 0002A23F L246:
207: 206 0002A23F # } while( index++ < max_cvlf_1_index );
208: 207 0002A23F L240:
209: 208 0002A23F L237:
210: 209 0002A23F 0d effffffe6f 50 movl _index,r0
211: 210 0002A246 6d effffffe68 incl _index
212: 211 0002A24C 1d 50 effffffe61 cmpl r0,_max_cvlf_1_index
213: 212 0002A253 81 03 13 ff1d jlss L238
214: 213 0002A258 L236:
215: 214 0002A258 # } /* end of subtest 1 */
216: 215 0002A258 40 ret#2
217: 216 0002A259 .set L232,0x0
218: 217 0002A259 L234:
219: 218 0002A259 13 ff0d jbr L235
220: 219 0002A25C .data
221: 220 00000db8 * .text
222: 221 0002A25C .align 1
223: 222 0002A25C .globl _pipe6_2
224: 223 0002A25C _pipe6_2:
225: 224 0002A25C 0000 .word L247
226: 225 0002A25E #
227: 226 0002A25E #
228: 227 0002A25E #
229: 228 0002A25E #
230: 229 0002A25E #
231: 230 0002A25E #
232: 231 0002A25E # /************************************************************************
233: 232 0002A25E # *
234: 233 0002A25E # * SUBTEST 2
235: 234 0002A25E # * data in registers, 1 NO-OP
236: 235 0002A25E # *
237: 236 0002A25E # ************************************************************************/
238: 237 0002A25E # pipe6_2()
239: 238 0002A25E # {
240: 239 0002A25E 13 00f5 jbr L249
241: 240 0002A261 L250:
242: 241 0002A261 # force_loop = FALSE; /* clear the force_loop flag */
243: 242 0002A261 4d effffffe4d clrl _force_loop
244: 243 0002A267 # index = 0;
245: 244 0002A267 4d effffffe47 clrl _index
246: 245 0002A26D # do
247: 246 0002A26D L253:
248: 247 0002A26D # {
249: 248 0002A26D # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
250: 249 0002A26D 0d effffffe41 50 movl _index,r0
251: 250 0002A274 48 03 50 50 shll $3,r0,r0
252: 251 0002A278 0d e000000000 effffffe31 movl _cvlf_1_data(r0),_sgl_value_1
253: 252 0002A283 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
254: 253 0002A283 0d effffffe2b 50 movl _index,r0
255: 254 0002A28A 48 03 50 50 shll $3,r0,r0
256: 255 0002A28E 0d e000000004 effffffe1b movl _cvlf_1_data+4(r0),_sgl_expected
257: 256 0002A299 # sgl_value_2 = 0x00000000; /* floating '0' */
258: 257 0002A299 4d effffffe15 clrl _sgl_value_2
259: 258 0002A29F # /*
260: 259 0002A29F # * If LOOP ON ERROR is set, this is the loop for this subtest.
261: 260 0002A29F # * The force loop flag is set after the first error.
262: 261 0002A29F # */
263: 262 0002A29F # asm("_pipe6_2_lp1:");
264: 263 0002A29F _pipe6_2_lp1:
265: 264 0002A29F # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
266: 265 0002A29F 0d effffffe0f 54 movl _sgl_value_1,r4
267: 266 0002A2A6 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
268: 267 0002A2A6 0d effffffe08 55 movl _sgl_value_2,r5
269: 268 0002A2AD # asm("movl _sgl_expected,r6"); /* save the expected result*/
270: 269 0002A2AD 0d effffffe01 56 movl _sgl_expected,r6
271: 270 0002A2B4 # asm("ldf r5"); /* load a floating '0' */
272: 271 0002A2B4 06 55 ldf r5
273: 272 0002A2B6 # asm("nop");
274: 273 0002A2B6 10 nop
275: 274 0002A2B7 # asm("addf r6"); /* add the expected value */
276: 275 0002A2B7 c6 56 addf r6
277: 276 0002A2B9 # asm("nop");
278: 277 0002A2B9 10 nop
279: 278 0002A2BA # asm("stf r7"); /* store the result */
280: 279 0002A2BA 26 57 stf r7
281: 280 0002A2BC # asm("nop");
282: 281 0002A2BC 10 nop
283: 282 0002A2BD # asm("cvlf r4"); /* convert the operand */
284: 283 0002A2BD 76 54 cvlf r4
285: 284 0002A2BF # asm("nop");
286: 285 0002A2BF 10 nop
287: 286 0002A2C0 # asm("subf r5"); /* subtract a floating '0' */
288: 287 0002A2C0 d6 55 subf r5
289: 288 0002A2C2 # asm("nop");
290: 289 0002A2C2 10 nop
291: 290 0002A2C3 # asm("stf r8"); /* store the result */
292: 291 0002A2C3 26 58 stf r8
293: 292 0002A2C5 # if( force_loop )
294: 293 0002A2C5 5d effffffde9 tstl _force_loop
295: 294 0002A2CB 31 02 jeql L254
296: 295 0002A2CD # asm("brb _pipe6_2_lp1");; /* loop on the error */
297: 296 0002A2CD 11 d0 brb _pipe6_2_lp1
298: 297 0002A2CF L254:
299: 298 0002A2CF # /*
300: 299 0002A2CF # * verify the results
301: 300 0002A2CF # */
302: 301 0002A2CF # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
303: 302 0002A2CF 0d 57 effffffdde movl r7,_sgl_st_acc
304: 303 0002A2D6 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
305: 304 0002A2D6 0d 58 effffffdd7 movl r8,_sgl_value_6
306: 305 0002A2DD # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
307: 306 0002A2DD # (sgl_value_6 != sgl_expected) )
308: 307 0002A2DD 1d effffffdd1 effffffdcc cmpl _sgl_st_acc,_sgl_expected
309: 308 0002A2E8 21 0d jneq L9998
310: 309 0002A2EA 1d effffffdc4 effffffdbf cmpl _sgl_value_6,_sgl_expected
311: 310 0002A2F5 31 45 jeql L255
312: 311 0002A2F7 L9998:
313: 312 0002A2F7 # {
314: 313 0002A2F7 # errcnt++; /* bump the error count */
315: 314 0002A2F7 6d effffffdb7 incl _errcnt
316: 315 0002A2FD # if ( prt_error )
317: 316 0002A2FD 5d effffffdb1 tstl _prt_error
318: 317 0002A303 31 0d jeql L256
319: 318 0002A305 # print_pipe6_er("Reg. Data, 1 NO-OP");
320: 319 0002A305 .data 1
321: 320 00000dd6 * L257:
322: 321 00000dd6 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
323: 04E4F2D4F5000
324: 322 00000de9 * .text
325: 323 0002A305 dd 8f00000dd6 pushl $L257
326: 324 0002A30B fe 08 ef00000996 callf $8,_print_pipe6_er
327: 325 0002A312 # if ( halt_flg ) /* halt on error? */
328: 326 0002A312 L256:
329: 327 0002A312 5d effffffd9c tstl _halt_flg
330: 328 0002A318 31 0d jeql L258
331: 329 0002A31A # pipe6_er_hlt( subtest );
332: 330 0002A31A dd effffffd94 pushl _subtest
333: 331 0002A320 fe 08 ef00000ac9 callf $8,_pipe6_er_hlt
334: 332 0002A327 # if ( loop_on_err ) {
335: 333 0002A327 L258:
336: 334 0002A327 5d effffffd87 tstl _loop_on_err
337: 335 0002A32D 31 0d jeql L259
338: 336 0002A32F # force_loop = TRUE; /* set the force loop flag */
339: 337 0002A32F 0d 01 effffffd7e movl $1,_force_loop
340: 338 0002A336 # asm("jmp _pipe6_2_lp1"); /* and loop */
341: 339 0002A336 71 efffffff63 jmp _pipe6_2_lp1
342: 340 0002A33C # }
343: 341 0002A33C # } /* end of compare error */
344: 342 0002A33C L259:
345: 343 0002A33C # } while( index++ < max_cvlf_1_index );
346: 344 0002A33C L255:
347: 345 0002A33C L252:
348: 346 0002A33C 0d effffffd72 50 movl _index,r0
349: 347 0002A343 6d effffffd6b incl _index
350: 348 0002A349 1d 50 effffffd64 cmpl r0,_max_cvlf_1_index
351: 349 0002A350 81 03 13 ff18 jlss L253
352: 350 0002A355 L251:
353: 351 0002A355 # } /* end of subtest 2 */
354: 352 0002A355 40 ret#2
355: 353 0002A356 .set L247,0x0
356: 354 0002A356 L249:
357: 355 0002A356 13 ff08 jbr L250
358: 356 0002A359 .data
359: 357 00000db8 * .text
360: 358 0002A359 00 .align 1
361: 359 0002A35A .globl _pipe6_3
362: 360 0002A35A _pipe6_3:
363: 361 0002A35A 0000 .word L260
364: 362 0002A35C #
365: 363 0002A35C #
366: 364 0002A35C #
367: 365 0002A35C #
368: 366 0002A35C #
369: 367 0002A35C #
370: 368 0002A35C # /************************************************************************
371: 369 0002A35C # *
372: 370 0002A35C # * SUBTEST 3
373: 371 0002A35C # * data in registers, 2 NO-OPs
374: 372 0002A35C # *
375: 373 0002A35C # ************************************************************************/
376: 374 0002A35C # pipe6_3()
377: 375 0002A35C # {
378: 376 0002A35C 13 00fa jbr L262
379: 377 0002A35F L263:
380: 378 0002A35F # force_loop = FALSE; /* clear the force_loop flag */
381: 379 0002A35F 4d effffffd4f clrl _force_loop
382: 380 0002A365 # index = 0;
383: 381 0002A365 4d effffffd49 clrl _index
384: 382 0002A36B # do
385: 383 0002A36B L266:
386: 384 0002A36B # {
387: 385 0002A36B # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
388: 386 0002A36B 0d effffffd43 50 movl _index,r0
389: 387 0002A372 48 03 50 50 shll $3,r0,r0
390: 388 0002A376 0d e000000000 effffffd33 movl _cvlf_1_data(r0),_sgl_value_1
391: 389 0002A381 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
392: 390 0002A381 0d effffffd2d 50 movl _index,r0
393: 391 0002A388 48 03 50 50 shll $3,r0,r0
394: 392 0002A38C 0d e000000004 effffffd1d movl _cvlf_1_data+4(r0),_sgl_expected
395: 393 0002A397 # sgl_value_2 = 0x00000000; /* floating '0' */
396: 394 0002A397 4d effffffd17 clrl _sgl_value_2
397: 395 0002A39D # /*
398: 396 0002A39D # * If LOOP ON ERROR is set, this is the loop for this subtest.
399: 397 0002A39D # * The force loop flag is set after the first error.
400: 398 0002A39D # */
401: 399 0002A39D # asm("_pipe6_3_lp1:");
402: 400 0002A39D _pipe6_3_lp1:
403: 401 0002A39D # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
404: 402 0002A39D 0d effffffd11 54 movl _sgl_value_1,r4
405: 403 0002A3A4 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
406: 404 0002A3A4 0d effffffd0a 55 movl _sgl_value_2,r5
407: 405 0002A3AB # asm("movl _sgl_expected,r6"); /* save the expected result*/
408: 406 0002A3AB 0d effffffd03 56 movl _sgl_expected,r6
409: 407 0002A3B2 # asm("ldf r5"); /* load a floating '0' */
410: 408 0002A3B2 06 55 ldf r5
411: 409 0002A3B4 # asm("nop");
412: 410 0002A3B4 10 nop
413: 411 0002A3B5 # asm("nop");
414: 412 0002A3B5 10 nop
415: 413 0002A3B6 # asm("addf r6"); /* add the expected value */
416: 414 0002A3B6 c6 56 addf r6
417: 415 0002A3B8 # asm("nop");
418: 416 0002A3B8 10 nop
419: 417 0002A3B9 # asm("nop");
420: 418 0002A3B9 10 nop
421: 419 0002A3BA # asm("stf r7"); /* store the result */
422: 420 0002A3BA 26 57 stf r7
423: 421 0002A3BC # asm("nop");
424: 422 0002A3BC 10 nop
425: 423 0002A3BD # asm("nop");
426: 424 0002A3BD 10 nop
427: 425 0002A3BE # asm("cvlf r4"); /* convert the operand */
428: 426 0002A3BE 76 54 cvlf r4
429: 427 0002A3C0 # asm("nop");
430: 428 0002A3C0 10 nop
431: 429 0002A3C1 # asm("nop");
432: 430 0002A3C1 10 nop
433: 431 0002A3C2 # asm("subf r5"); /* subtract a floating '0' */
434: 432 0002A3C2 d6 55 subf r5
435: 433 0002A3C4 # asm("nop");
436: 434 0002A3C4 10 nop
437: 435 0002A3C5 # asm("nop");
438: 436 0002A3C5 10 nop
439: 437 0002A3C6 # asm("stf r8"); /* store the result */
440: 438 0002A3C6 26 58 stf r8
441: 439 0002A3C8 # if( force_loop )
442: 440 0002A3C8 5d effffffce6 tstl _force_loop
443: 441 0002A3CE 31 02 jeql L267
444: 442 0002A3D0 # asm("brb _pipe6_3_lp1");; /* loop on the error */
445: 443 0002A3D0 11 cb brb _pipe6_3_lp1
446: 444 0002A3D2 L267:
447: 445 0002A3D2 # /*
448: 446 0002A3D2 # * verify the results
449: 447 0002A3D2 # */
450: 448 0002A3D2 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
451: 449 0002A3D2 0d 57 effffffcdb movl r7,_sgl_st_acc
452: 450 0002A3D9 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
453: 451 0002A3D9 0d 58 effffffcd4 movl r8,_sgl_value_6
454: 452 0002A3E0 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
455: 453 0002A3E0 # (sgl_value_6 != sgl_expected) )
456: 454 0002A3E0 1d effffffcce effffffcc9 cmpl _sgl_st_acc,_sgl_expected
457: 455 0002A3EB 21 0d jneq L9997
458: 456 0002A3ED 1d effffffcc1 effffffcbc cmpl _sgl_value_6,_sgl_expected
459: 457 0002A3F8 31 45 jeql L268
460: 458 0002A3FA L9997:
461: 459 0002A3FA # {
462: 460 0002A3FA # errcnt++; /* bump the error count */
463: 461 0002A3FA 6d effffffcb4 incl _errcnt
464: 462 0002A400 # if ( prt_error )
465: 463 0002A400 5d effffffcae tstl _prt_error
466: 464 0002A406 31 0d jeql L269
467: 465 0002A408 # print_pipe6_er("Reg. Data, 2 NO-OPs");
468: 466 0002A408 .data 1
469: 467 00000de9 * L270:
470: 468 00000de9 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
471: 04E4F2D4F507300
472: 469 00000dfd * .text
473: 470 0002A408 dd 8f00000de9 pushl $L270
474: 471 0002A40E fe 08 ef00000893 callf $8,_print_pipe6_er
475: 472 0002A415 # if ( halt_flg ) /* halt on error? */
476: 473 0002A415 L269:
477: 474 0002A415 5d effffffc99 tstl _halt_flg
478: 475 0002A41B 31 0d jeql L271
479: 476 0002A41D # pipe6_er_hlt( subtest );
480: 477 0002A41D dd effffffc91 pushl _subtest
481: 478 0002A423 fe 08 ef000009c6 callf $8,_pipe6_er_hlt
482: 479 0002A42A # if ( loop_on_err ) {
483: 480 0002A42A L271:
484: 481 0002A42A 5d effffffc84 tstl _loop_on_err
485: 482 0002A430 31 0d jeql L272
486: 483 0002A432 # force_loop = TRUE; /* set the force loop flag */
487: 484 0002A432 0d 01 effffffc7b movl $1,_force_loop
488: 485 0002A439 # asm("jmp _pipe6_3_lp1"); /* and loop */
489: 486 0002A439 71 efffffff5e jmp _pipe6_3_lp1
490: 487 0002A43F # }
491: 488 0002A43F # } /* end of compare error */
492: 489 0002A43F L272:
493: 490 0002A43F # } while( index++ < max_cvlf_1_index );
494: 491 0002A43F L268:
495: 492 0002A43F L265:
496: 493 0002A43F 0d effffffc6f 50 movl _index,r0
497: 494 0002A446 6d effffffc68 incl _index
498: 495 0002A44C 1d 50 effffffc61 cmpl r0,_max_cvlf_1_index
499: 496 0002A453 81 03 13 ff13 jlss L266
500: 497 0002A458 L264:
501: 498 0002A458 # } /* end of subtest 3 */
502: 499 0002A458 40 ret#2
503: 500 0002A459 .set L260,0x0
504: 501 0002A459 L262:
505: 502 0002A459 13 ff03 jbr L263
506: 503 0002A45C .data
507: 504 00000db8 * .text
508: 505 0002A45C .align 1
509: 506 0002A45C .globl _pipe6_4
510: 507 0002A45C _pipe6_4:
511: 508 0002A45C 0000 .word L273
512: 509 0002A45E #
513: 510 0002A45E #
514: 511 0002A45E #
515: 512 0002A45E #
516: 513 0002A45E #
517: 514 0002A45E #
518: 515 0002A45E # /************************************************************************
519: 516 0002A45E # *
520: 517 0002A45E # * SUBTEST 4
521: 518 0002A45E # * data in registers, 3 NO-OPs
522: 519 0002A45E # *
523: 520 0002A45E # ************************************************************************/
524: 521 0002A45E # pipe6_4()
525: 522 0002A45E # {
526: 523 0002A45E 13 00ff jbr L275
527: 524 0002A461 L276:
528: 525 0002A461 # force_loop = FALSE; /* clear the force_loop flag */
529: 526 0002A461 4d effffffc4d clrl _force_loop
530: 527 0002A467 # index = 0;
531: 528 0002A467 4d effffffc47 clrl _index
532: 529 0002A46D # do
533: 530 0002A46D L279:
534: 531 0002A46D # {
535: 532 0002A46D # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
536: 533 0002A46D 0d effffffc41 50 movl _index,r0
537: 534 0002A474 48 03 50 50 shll $3,r0,r0
538: 535 0002A478 0d e000000000 effffffc31 movl _cvlf_1_data(r0),_sgl_value_1
539: 536 0002A483 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
540: 537 0002A483 0d effffffc2b 50 movl _index,r0
541: 538 0002A48A 48 03 50 50 shll $3,r0,r0
542: 539 0002A48E 0d e000000004 effffffc1b movl _cvlf_1_data+4(r0),_sgl_expected
543: 540 0002A499 # sgl_value_2 = 0x00000000; /* floating '0' */
544: 541 0002A499 4d effffffc15 clrl _sgl_value_2
545: 542 0002A49F # /*
546: 543 0002A49F # * If LOOP ON ERROR is set, this is the loop for this subtest.
547: 544 0002A49F # * The force loop flag is set after the first error.
548: 545 0002A49F # */
549: 546 0002A49F # asm("_pipe6_4_lp1:");
550: 547 0002A49F _pipe6_4_lp1:
551: 548 0002A49F # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
552: 549 0002A49F 0d effffffc0f 54 movl _sgl_value_1,r4
553: 550 0002A4A6 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
554: 551 0002A4A6 0d effffffc08 55 movl _sgl_value_2,r5
555: 552 0002A4AD # asm("movl _sgl_expected,r6"); /* save the expected result*/
556: 553 0002A4AD 0d effffffc01 56 movl _sgl_expected,r6
557: 554 0002A4B4 # asm("ldf r5"); /* load a floating '0' */
558: 555 0002A4B4 06 55 ldf r5
559: 556 0002A4B6 # asm("nop");
560: 557 0002A4B6 10 nop
561: 558 0002A4B7 # asm("nop");
562: 559 0002A4B7 10 nop
563: 560 0002A4B8 # asm("nop");
564: 561 0002A4B8 10 nop
565: 562 0002A4B9 # asm("addf r6"); /* add the expected value */
566: 563 0002A4B9 c6 56 addf r6
567: 564 0002A4BB # asm("nop");
568: 565 0002A4BB 10 nop
569: 566 0002A4BC # asm("nop");
570: 567 0002A4BC 10 nop
571: 568 0002A4BD # asm("nop");
572: 569 0002A4BD 10 nop
573: 570 0002A4BE # asm("stf r7"); /* store the result */
574: 571 0002A4BE 26 57 stf r7
575: 572 0002A4C0 # asm("nop");
576: 573 0002A4C0 10 nop
577: 574 0002A4C1 # asm("nop");
578: 575 0002A4C1 10 nop
579: 576 0002A4C2 # asm("nop");
580: 577 0002A4C2 10 nop
581: 578 0002A4C3 # asm("cvlf r4"); /* convert the operand */
582: 579 0002A4C3 76 54 cvlf r4
583: 580 0002A4C5 # asm("nop");
584: 581 0002A4C5 10 nop
585: 582 0002A4C6 # asm("nop");
586: 583 0002A4C6 10 nop
587: 584 0002A4C7 # asm("nop");
588: 585 0002A4C7 10 nop
589: 586 0002A4C8 # asm("subf r5"); /* subtract a floating '0' */
590: 587 0002A4C8 d6 55 subf r5
591: 588 0002A4CA # asm("nop");
592: 589 0002A4CA 10 nop
593: 590 0002A4CB # asm("nop");
594: 591 0002A4CB 10 nop
595: 592 0002A4CC # asm("nop");
596: 593 0002A4CC 10 nop
597: 594 0002A4CD # asm("stf r8"); /* store the result */
598: 595 0002A4CD 26 58 stf r8
599: 596 0002A4CF # if( force_loop )
600: 597 0002A4CF 5d effffffbdf tstl _force_loop
601: 598 0002A4D5 31 02 jeql L280
602: 599 0002A4D7 # asm("brb _pipe6_4_lp1");; /* loop on the error */
603: 600 0002A4D7 11 c6 brb _pipe6_4_lp1
604: 601 0002A4D9 L280:
605: 602 0002A4D9 # /*
606: 603 0002A4D9 # * verify the results
607: 604 0002A4D9 # */
608: 605 0002A4D9 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
609: 606 0002A4D9 0d 57 effffffbd4 movl r7,_sgl_st_acc
610: 607 0002A4E0 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
611: 608 0002A4E0 0d 58 effffffbcd movl r8,_sgl_value_6
612: 609 0002A4E7 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
613: 610 0002A4E7 # (sgl_value_6 != sgl_expected) )
614: 611 0002A4E7 1d effffffbc7 effffffbc2 cmpl _sgl_st_acc,_sgl_expected
615: 612 0002A4F2 21 0d jneq L9996
616: 613 0002A4F4 1d effffffbba effffffbb5 cmpl _sgl_value_6,_sgl_expected
617: 614 0002A4FF 31 45 jeql L281
618: 615 0002A501 L9996:
619: 616 0002A501 # {
620: 617 0002A501 # errcnt++; /* bump the error count */
621: 618 0002A501 6d effffffbad incl _errcnt
622: 619 0002A507 # if ( prt_error )
623: 620 0002A507 5d effffffba7 tstl _prt_error
624: 621 0002A50D 31 0d jeql L282
625: 622 0002A50F # print_pipe6_er("Reg. Data, 3 NO-OPs");
626: 623 0002A50F .data 1
627: 624 00000dfd * L283:
628: 625 00000dfd * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
629: 04E4F2D4F507300
630: 626 00000e11 * .text
631: 627 0002A50F dd 8f00000dfd pushl $L283
632: 628 0002A515 fe 08 ef0000078c callf $8,_print_pipe6_er
633: 629 0002A51C # if ( halt_flg ) /* halt on error? */
634: 630 0002A51C L282:
635: 631 0002A51C 5d effffffb92 tstl _halt_flg
636: 632 0002A522 31 0d jeql L284
637: 633 0002A524 # pipe6_er_hlt( subtest );
638: 634 0002A524 dd effffffb8a pushl _subtest
639: 635 0002A52A fe 08 ef000008bf callf $8,_pipe6_er_hlt
640: 636 0002A531 # if ( loop_on_err ) {
641: 637 0002A531 L284:
642: 638 0002A531 5d effffffb7d tstl _loop_on_err
643: 639 0002A537 31 0d jeql L285
644: 640 0002A539 # force_loop = TRUE; /* set the force loop flag */
645: 641 0002A539 0d 01 effffffb74 movl $1,_force_loop
646: 642 0002A540 # asm("jmp _pipe6_4_lp1"); /* and loop */
647: 643 0002A540 71 efffffff59 jmp _pipe6_4_lp1
648: 644 0002A546 # }
649: 645 0002A546 # } /* end of compare error */
650: 646 0002A546 L285:
651: 647 0002A546 # } while( index++ < max_cvlf_1_index );
652: 648 0002A546 L281:
653: 649 0002A546 L278:
654: 650 0002A546 0d effffffb68 50 movl _index,r0
655: 651 0002A54D 6d effffffb61 incl _index
656: 652 0002A553 1d 50 effffffb5a cmpl r0,_max_cvlf_1_index
657: 653 0002A55A 81 03 13 ff0e jlss L279
658: 654 0002A55F L277:
659: 655 0002A55F # } /* end of subtest 4 */
660: 656 0002A55F 40 ret#2
661: 657 0002A560 .set L273,0x0
662: 658 0002A560 L275:
663: 659 0002A560 13 fefe jbr L276
664: 660 0002A563 .data
665: 661 00000db8 * .text
666: 662 0002A563 00 .align 1
667: 663 0002A564 .globl _pipe6_5
668: 664 0002A564 _pipe6_5:
669: 665 0002A564 0000 .word L286
670: 666 0002A566 #
671: 667 0002A566 #
672: 668 0002A566 #
673: 669 0002A566 #
674: 670 0002A566 #
675: 671 0002A566 #
676: 672 0002A566 #
677: 673 0002A566 # /************************************************************************
678: 674 0002A566 # *
679: 675 0002A566 # * SUBTEST 5
680: 676 0002A566 # * data in Cache, no NO-OPs
681: 677 0002A566 # *
682: 678 0002A566 # ************************************************************************/
683: 679 0002A566 # pipe6_5()
684: 680 0002A566 # {
685: 681 0002A566 13 00e5 jbr L288
686: 682 0002A569 L289:
687: 683 0002A569 # force_loop = FALSE; /* clear the force_loop flag */
688: 684 0002A569 4d effffffb45 clrl _force_loop
689: 685 0002A56F # index = 0;
690: 686 0002A56F 4d effffffb3f clrl _index
691: 687 0002A575 # do
692: 688 0002A575 L292:
693: 689 0002A575 # {
694: 690 0002A575 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
695: 691 0002A575 0d effffffb39 50 movl _index,r0
696: 692 0002A57C 48 03 50 50 shll $3,r0,r0
697: 693 0002A580 0d e000000000 effffffb29 movl _cvlf_1_data(r0),_sgl_value_1
698: 694 0002A58B # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
699: 695 0002A58B 0d effffffb23 50 movl _index,r0
700: 696 0002A592 48 03 50 50 shll $3,r0,r0
701: 697 0002A596 0d e000000004 effffffb13 movl _cvlf_1_data+4(r0),_sgl_expected
702: 698 0002A5A1 # sgl_value_2 = 0x00000000; /* floating '0' */
703: 699 0002A5A1 4d effffffb0d clrl _sgl_value_2
704: 700 0002A5A7 # /*
705: 701 0002A5A7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
706: 702 0002A5A7 # * The force loop flag is set after the first error.
707: 703 0002A5A7 # */
708: 704 0002A5A7 # asm("_pipe6_5_lp1:");
709: 705 0002A5A7 _pipe6_5_lp1:
710: 706 0002A5A7 # asm("ldf _sgl_value_2"); /* load a floating '0' */
711: 707 0002A5A7 06 effffffb07 ldf _sgl_value_2
712: 708 0002A5AD # asm("addf _sgl_expected"); /* add the expected value */
713: 709 0002A5AD c6 effffffb01 addf _sgl_expected
714: 710 0002A5B3 # asm("stf _sgl_st_acc"); /* store the result */
715: 711 0002A5B3 26 effffffafb stf _sgl_st_acc
716: 712 0002A5B9 # asm("cvlf _sgl_value_1"); /* convert the int operand */
717: 713 0002A5B9 76 effffffaf5 cvlf _sgl_value_1
718: 714 0002A5BF # asm("subf _sgl_value_2"); /* subtract a floating '0' */
719: 715 0002A5BF d6 effffffaef subf _sgl_value_2
720: 716 0002A5C5 # asm("stf _sgl_value_6"); /* store the result */
721: 717 0002A5C5 26 effffffae9 stf _sgl_value_6
722: 718 0002A5CB # if( force_loop )
723: 719 0002A5CB 5d effffffae3 tstl _force_loop
724: 720 0002A5D1 31 02 jeql L293
725: 721 0002A5D3 # asm("brb _pipe6_5_lp1");; /* loop on the error */
726: 722 0002A5D3 11 d2 brb _pipe6_5_lp1
727: 723 0002A5D5 L293:
728: 724 0002A5D5 # /*
729: 725 0002A5D5 # * verify the results
730: 726 0002A5D5 # */
731: 727 0002A5D5 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
732: 728 0002A5D5 # (sgl_value_6 != sgl_expected) )
733: 729 0002A5D5 1d effffffad9 effffffad4 cmpl _sgl_st_acc,_sgl_expected
734: 730 0002A5E0 21 0d jneq L9995
735: 731 0002A5E2 1d effffffacc effffffac7 cmpl _sgl_value_6,_sgl_expected
736: 732 0002A5ED 31 45 jeql L294
737: 733 0002A5EF L9995:
738: 734 0002A5EF # {
739: 735 0002A5EF # errcnt++; /* bump the error count */
740: 736 0002A5EF 6d effffffabf incl _errcnt
741: 737 0002A5F5 # if ( prt_error )
742: 738 0002A5F5 5d effffffab9 tstl _prt_error
743: 739 0002A5FB 31 0d jeql L295
744: 740 0002A5FD # print_pipe6_er("Cache Data, no NO-OPs");
745: 741 0002A5FD .data 1
746: 742 00000e11 * L296:
747: 743 00000e11 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
748: E6F204E4F2D4F507300
749: 744 00000e27 * .text
750: 745 0002A5FD dd 8f00000e11 pushl $L296
751: 746 0002A603 fe 08 ef0000069e callf $8,_print_pipe6_er
752: 747 0002A60A # if ( halt_flg ) /* halt on error? */
753: 748 0002A60A L295:
754: 749 0002A60A 5d effffffaa4 tstl _halt_flg
755: 750 0002A610 31 0d jeql L297
756: 751 0002A612 # pipe6_er_hlt( subtest );
757: 752 0002A612 dd effffffa9c pushl _subtest
758: 753 0002A618 fe 08 ef000007d1 callf $8,_pipe6_er_hlt
759: 754 0002A61F # if ( loop_on_err ) {
760: 755 0002A61F L297:
761: 756 0002A61F 5d effffffa8f tstl _loop_on_err
762: 757 0002A625 31 0d jeql L298
763: 758 0002A627 # force_loop = TRUE; /* set the force loop flag */
764: 759 0002A627 0d 01 effffffa86 movl $1,_force_loop
765: 760 0002A62E # asm("jmp _pipe6_5_lp1"); /* and loop */
766: 761 0002A62E 71 efffffff73 jmp _pipe6_5_lp1
767: 762 0002A634 # }
768: 763 0002A634 # } /* end of compare error */
769: 764 0002A634 L298:
770: 765 0002A634 # } while( index++ < max_cvlf_1_index );
771: 766 0002A634 L294:
772: 767 0002A634 L291:
773: 768 0002A634 0d effffffa7a 50 movl _index,r0
774: 769 0002A63B 6d effffffa73 incl _index
775: 770 0002A641 1d 50 effffffa6c cmpl r0,_max_cvlf_1_index
776: 771 0002A648 81 03 13 ff28 jlss L292
777: 772 0002A64D L290:
778: 773 0002A64D # } /* end of subtest 5 */
779: 774 0002A64D 40 ret#2
780: 775 0002A64E .set L286,0x0
781: 776 0002A64E L288:
782: 777 0002A64E 13 ff18 jbr L289
783: 778 0002A651 .data
784: 779 00000db8 * .text
785: 780 0002A651 00 .align 1
786: 781 0002A652 .globl _pipe6_6
787: 782 0002A652 _pipe6_6:
788: 783 0002A652 0000 .word L299
789: 784 0002A654 #
790: 785 0002A654 #
791: 786 0002A654 #
792: 787 0002A654 #
793: 788 0002A654 #
794: 789 0002A654 #
795: 790 0002A654 # /************************************************************************
796: 791 0002A654 # *
797: 792 0002A654 # * SUBTEST 6
798: 793 0002A654 # * data in Cache, 1 NO-OP
799: 794 0002A654 # *
800: 795 0002A654 # ************************************************************************/
801: 796 0002A654 # pipe6_6()
802: 797 0002A654 # {
803: 798 0002A654 13 00ea jbr L301
804: 799 0002A657 L302:
805: 800 0002A657 # force_loop = FALSE; /* clear the force_loop flag */
806: 801 0002A657 4d effffffa57 clrl _force_loop
807: 802 0002A65D # index = 0;
808: 803 0002A65D 4d effffffa51 clrl _index
809: 804 0002A663 # do
810: 805 0002A663 L305:
811: 806 0002A663 # {
812: 807 0002A663 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
813: 808 0002A663 0d effffffa4b 50 movl _index,r0
814: 809 0002A66A 48 03 50 50 shll $3,r0,r0
815: 810 0002A66E 0d e000000000 effffffa3b movl _cvlf_1_data(r0),_sgl_value_1
816: 811 0002A679 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
817: 812 0002A679 0d effffffa35 50 movl _index,r0
818: 813 0002A680 48 03 50 50 shll $3,r0,r0
819: 814 0002A684 0d e000000004 effffffa25 movl _cvlf_1_data+4(r0),_sgl_expected
820: 815 0002A68F # sgl_value_2 = 0x00000000; /* floating '0' */
821: 816 0002A68F 4d effffffa1f clrl _sgl_value_2
822: 817 0002A695 # /*
823: 818 0002A695 # * If LOOP ON ERROR is set, this is the loop for this subtest.
824: 819 0002A695 # * The force loop flag is set after the first error.
825: 820 0002A695 # */
826: 821 0002A695 # asm("_pipe6_6_lp1:");
827: 822 0002A695 _pipe6_6_lp1:
828: 823 0002A695 # asm("ldf _sgl_value_2"); /* load a floating '0' */
829: 824 0002A695 06 effffffa19 ldf _sgl_value_2
830: 825 0002A69B # asm("nop");
831: 826 0002A69B 10 nop
832: 827 0002A69C # asm("addf _sgl_expected"); /* add the expected value */
833: 828 0002A69C c6 effffffa12 addf _sgl_expected
834: 829 0002A6A2 # asm("nop");
835: 830 0002A6A2 10 nop
836: 831 0002A6A3 # asm("stf _sgl_st_acc"); /* store the result */
837: 832 0002A6A3 26 effffffa0b stf _sgl_st_acc
838: 833 0002A6A9 # asm("nop");
839: 834 0002A6A9 10 nop
840: 835 0002A6AA # asm("cvlf _sgl_value_1"); /* convert the int operand */
841: 836 0002A6AA 76 effffffa04 cvlf _sgl_value_1
842: 837 0002A6B0 # asm("nop");
843: 838 0002A6B0 10 nop
844: 839 0002A6B1 # asm("subf _sgl_value_2"); /* subtract a floating '0' */
845: 840 0002A6B1 d6 effffff9fd subf _sgl_value_2
846: 841 0002A6B7 # asm("nop");
847: 842 0002A6B7 10 nop
848: 843 0002A6B8 # asm("stf _sgl_value_6"); /* store the result */
849: 844 0002A6B8 26 effffff9f6 stf _sgl_value_6
850: 845 0002A6BE # if( force_loop )
851: 846 0002A6BE 5d effffff9f0 tstl _force_loop
852: 847 0002A6C4 31 02 jeql L306
853: 848 0002A6C6 # asm("brb _pipe6_6_lp1");; /* loop on the error */
854: 849 0002A6C6 11 cd brb _pipe6_6_lp1
855: 850 0002A6C8 L306:
856: 851 0002A6C8 # /*
857: 852 0002A6C8 # * verify the results
858: 853 0002A6C8 # */
859: 854 0002A6C8 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
860: 855 0002A6C8 # (sgl_value_6 != sgl_expected) )
861: 856 0002A6C8 1d effffff9e6 effffff9e1 cmpl _sgl_st_acc,_sgl_expected
862: 857 0002A6D3 21 0d jneq L9994
863: 858 0002A6D5 1d effffff9d9 effffff9d4 cmpl _sgl_value_6,_sgl_expected
864: 859 0002A6E0 31 45 jeql L307
865: 860 0002A6E2 L9994:
866: 861 0002A6E2 # {
867: 862 0002A6E2 # errcnt++; /* bump the error count */
868: 863 0002A6E2 6d effffff9cc incl _errcnt
869: 864 0002A6E8 # if ( prt_error )
870: 865 0002A6E8 5d effffff9c6 tstl _prt_error
871: 866 0002A6EE 31 0d jeql L308
872: 867 0002A6F0 # print_pipe6_er("Cache Data, 1 NO-OP");
873: 868 0002A6F0 .data 1
874: 869 00000e27 * L309:
875: 870 00000e27 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
876: 1204E4F2D4F5000
877: 871 00000e3b * .text
878: 872 0002A6F0 dd 8f00000e27 pushl $L309
879: 873 0002A6F6 fe 08 ef000005ab callf $8,_print_pipe6_er
880: 874 0002A6FD # if ( halt_flg ) /* halt on error? */
881: 875 0002A6FD L308:
882: 876 0002A6FD 5d effffff9b1 tstl _halt_flg
883: 877 0002A703 31 0d jeql L310
884: 878 0002A705 # pipe6_er_hlt( subtest );
885: 879 0002A705 dd effffff9a9 pushl _subtest
886: 880 0002A70B fe 08 ef000006de callf $8,_pipe6_er_hlt
887: 881 0002A712 # if ( loop_on_err ) {
888: 882 0002A712 L310:
889: 883 0002A712 5d effffff99c tstl _loop_on_err
890: 884 0002A718 31 0d jeql L311
891: 885 0002A71A # force_loop = TRUE; /* set the force loop flag */
892: 886 0002A71A 0d 01 effffff993 movl $1,_force_loop
893: 887 0002A721 # asm("jmp _pipe6_6_lp1"); /* and loop */
894: 888 0002A721 71 efffffff6e jmp _pipe6_6_lp1
895: 889 0002A727 # }
896: 890 0002A727 # } /* end of compare error */
897: 891 0002A727 L311:
898: 892 0002A727 # } while( index++ < max_cvlf_1_index );
899: 893 0002A727 L307:
900: 894 0002A727 L304:
901: 895 0002A727 0d effffff987 50 movl _index,r0
902: 896 0002A72E 6d effffff980 incl _index
903: 897 0002A734 1d 50 effffff979 cmpl r0,_max_cvlf_1_index
904: 898 0002A73B 81 03 13 ff23 jlss L305
905: 899 0002A740 L303:
906: 900 0002A740 # } /* end of subtest 6 */
907: 901 0002A740 40 ret#2
908: 902 0002A741 .set L299,0x0
909: 903 0002A741 L301:
910: 904 0002A741 13 ff13 jbr L302
911: 905 0002A744 .data
912: 906 00000db8 * .text
913: 907 0002A744 .align 1
914: 908 0002A744 .globl _pipe6_7
915: 909 0002A744 _pipe6_7:
916: 910 0002A744 0000 .word L312
917: 911 0002A746 #
918: 912 0002A746 #
919: 913 0002A746 #
920: 914 0002A746 #
921: 915 0002A746 #
922: 916 0002A746 #
923: 917 0002A746 # /************************************************************************
924: 918 0002A746 # *
925: 919 0002A746 # * SUBTEST 7
926: 920 0002A746 # * data in Cache, 2 NO-OPs
927: 921 0002A746 # *
928: 922 0002A746 # ************************************************************************/
929: 923 0002A746 # pipe6_7()
930: 924 0002A746 # {
931: 925 0002A746 13 00ef jbr L314
932: 926 0002A749 L315:
933: 927 0002A749 # force_loop = FALSE; /* clear the force_loop flag */
934: 928 0002A749 4d effffff965 clrl _force_loop
935: 929 0002A74F # index = 0;
936: 930 0002A74F 4d effffff95f clrl _index
937: 931 0002A755 # do
938: 932 0002A755 L318:
939: 933 0002A755 # {
940: 934 0002A755 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
941: 935 0002A755 0d effffff959 50 movl _index,r0
942: 936 0002A75C 48 03 50 50 shll $3,r0,r0
943: 937 0002A760 0d e000000000 effffff949 movl _cvlf_1_data(r0),_sgl_value_1
944: 938 0002A76B # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
945: 939 0002A76B 0d effffff943 50 movl _index,r0
946: 940 0002A772 48 03 50 50 shll $3,r0,r0
947: 941 0002A776 0d e000000004 effffff933 movl _cvlf_1_data+4(r0),_sgl_expected
948: 942 0002A781 # sgl_value_2 = 0x00000000; /* floating '0' */
949: 943 0002A781 4d effffff92d clrl _sgl_value_2
950: 944 0002A787 # /*
951: 945 0002A787 # * If LOOP ON ERROR is set, this is the loop for this subtest.
952: 946 0002A787 # * The force loop flag is set after the first error.
953: 947 0002A787 # */
954: 948 0002A787 # asm("_pipe6_7_lp1:");
955: 949 0002A787 _pipe6_7_lp1:
956: 950 0002A787 # asm("ldf _sgl_value_2"); /* load a floating '0' */
957: 951 0002A787 06 effffff927 ldf _sgl_value_2
958: 952 0002A78D # asm("nop");
959: 953 0002A78D 10 nop
960: 954 0002A78E # asm("nop");
961: 955 0002A78E 10 nop
962: 956 0002A78F # asm("addf _sgl_expected"); /* add the expected value */
963: 957 0002A78F c6 effffff91f addf _sgl_expected
964: 958 0002A795 # asm("nop");
965: 959 0002A795 10 nop
966: 960 0002A796 # asm("nop");
967: 961 0002A796 10 nop
968: 962 0002A797 # asm("stf _sgl_st_acc"); /* store the result */
969: 963 0002A797 26 effffff917 stf _sgl_st_acc
970: 964 0002A79D # asm("nop");
971: 965 0002A79D 10 nop
972: 966 0002A79E # asm("nop");
973: 967 0002A79E 10 nop
974: 968 0002A79F # asm("cvlf _sgl_value_1"); /* convert the int operand */
975: 969 0002A79F 76 effffff90f cvlf _sgl_value_1
976: 970 0002A7A5 # asm("nop");
977: 971 0002A7A5 10 nop
978: 972 0002A7A6 # asm("nop");
979: 973 0002A7A6 10 nop
980: 974 0002A7A7 # asm("subf _sgl_value_2"); /* subtract a floating '0' */
981: 975 0002A7A7 d6 effffff907 subf _sgl_value_2
982: 976 0002A7AD # asm("nop");
983: 977 0002A7AD 10 nop
984: 978 0002A7AE # asm("nop");
985: 979 0002A7AE 10 nop
986: 980 0002A7AF # asm("stf _sgl_value_6"); /* store the result */
987: 981 0002A7AF 26 effffff8ff stf _sgl_value_6
988: 982 0002A7B5 # if( force_loop )
989: 983 0002A7B5 5d effffff8f9 tstl _force_loop
990: 984 0002A7BB 31 02 jeql L319
991: 985 0002A7BD # asm("brb _pipe6_7_lp1");; /* loop on the error */
992: 986 0002A7BD 11 c8 brb _pipe6_7_lp1
993: 987 0002A7BF L319:
994: 988 0002A7BF # /*
995: 989 0002A7BF # * verify the results
996: 990 0002A7BF # */
997: 991 0002A7BF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
998: 992 0002A7BF # (sgl_value_6 != sgl_expected) )
999: 993 0002A7BF 1d effffff8ef effffff8ea cmpl _sgl_st_acc,_sgl_expected
1000: 994 0002A7CA 21 0d jneq L9993
1001: 995 0002A7CC 1d effffff8e2 effffff8dd cmpl _sgl_value_6,_sgl_expected
1002: 996 0002A7D7 31 45 jeql L320
1003: 997 0002A7D9 L9993:
1004: 998 0002A7D9 # {
1005: 999 0002A7D9 # errcnt++; /* bump the error count */
1006: 1000 0002A7D9 6d effffff8d5 incl _errcnt
1007: 1001 0002A7DF # if ( prt_error )
1008: 1002 0002A7DF 5d effffff8cf tstl _prt_error
1009: 1003 0002A7E5 31 0d jeql L321
1010: 1004 0002A7E7 # print_pipe6_er("Cache Data, 2 NO-OPs");
1011: 1005 0002A7E7 .data 1
1012: 1006 00000e3b * L322:
1013: 1007 00000e3b * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
1014: 2204E4F2D4F507300
1015: 1008 00000e50 * .text
1016: 1009 0002A7E7 dd 8f00000e3b pushl $L322
1017: 1010 0002A7ED fe 08 ef000004b4 callf $8,_print_pipe6_er
1018: 1011 0002A7F4 # if ( halt_flg ) /* halt on error? */
1019: 1012 0002A7F4 L321:
1020: 1013 0002A7F4 5d effffff8ba tstl _halt_flg
1021: 1014 0002A7FA 31 0d jeql L323
1022: 1015 0002A7FC # pipe6_er_hlt( subtest );
1023: 1016 0002A7FC dd effffff8b2 pushl _subtest
1024: 1017 0002A802 fe 08 ef000005e7 callf $8,_pipe6_er_hlt
1025: 1018 0002A809 # if ( loop_on_err ) {
1026: 1019 0002A809 L323:
1027: 1020 0002A809 5d effffff8a5 tstl _loop_on_err
1028: 1021 0002A80F 31 0d jeql L324
1029: 1022 0002A811 # force_loop = TRUE; /* set the force loop flag */
1030: 1023 0002A811 0d 01 effffff89c movl $1,_force_loop
1031: 1024 0002A818 # asm("jmp _pipe6_7_lp1"); /* and loop */
1032: 1025 0002A818 71 efffffff69 jmp _pipe6_7_lp1
1033: 1026 0002A81E # }
1034: 1027 0002A81E # } /* end of compare error */
1035: 1028 0002A81E L324:
1036: 1029 0002A81E # } while( index++ < max_cvlf_1_index );
1037: 1030 0002A81E L320:
1038: 1031 0002A81E L317:
1039: 1032 0002A81E 0d effffff890 50 movl _index,r0
1040: 1033 0002A825 6d effffff889 incl _index
1041: 1034 0002A82B 1d 50 effffff882 cmpl r0,_max_cvlf_1_index
1042: 1035 0002A832 81 03 13 ff1e jlss L318
1043: 1036 0002A837 L316:
1044: 1037 0002A837 # } /* end of subtest 7 */
1045: 1038 0002A837 40 ret#2
1046: 1039 0002A838 .set L312,0x0
1047: 1040 0002A838 L314:
1048: 1041 0002A838 13 ff0e jbr L315
1049: 1042 0002A83B .data
1050: 1043 00000db8 * .text
1051: 1044 0002A83B 00 .align 1
1052: 1045 0002A83C .globl _pipe6_8
1053: 1046 0002A83C _pipe6_8:
1054: 1047 0002A83C 0000 .word L325
1055: 1048 0002A83E #
1056: 1049 0002A83E #
1057: 1050 0002A83E #
1058: 1051 0002A83E #
1059: 1052 0002A83E #
1060: 1053 0002A83E #
1061: 1054 0002A83E # /************************************************************************
1062: 1055 0002A83E # *
1063: 1056 0002A83E # * SUBTEST 8
1064: 1057 0002A83E # * data in Cache, 3 NO-OPs
1065: 1058 0002A83E # *
1066: 1059 0002A83E # ************************************************************************/
1067: 1060 0002A83E # pipe6_8()
1068: 1061 0002A83E # {
1069: 1062 0002A83E 13 00f4 jbr L327
1070: 1063 0002A841 L328:
1071: 1064 0002A841 # force_loop = FALSE; /* clear the force_loop flag */
1072: 1065 0002A841 4d effffff86d clrl _force_loop
1073: 1066 0002A847 # index = 0;
1074: 1067 0002A847 4d effffff867 clrl _index
1075: 1068 0002A84D # do
1076: 1069 0002A84D L331:
1077: 1070 0002A84D # {
1078: 1071 0002A84D # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1079: 1072 0002A84D 0d effffff861 50 movl _index,r0
1080: 1073 0002A854 48 03 50 50 shll $3,r0,r0
1081: 1074 0002A858 0d e000000000 effffff851 movl _cvlf_1_data(r0),_sgl_value_1
1082: 1075 0002A863 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1083: 1076 0002A863 0d effffff84b 50 movl _index,r0
1084: 1077 0002A86A 48 03 50 50 shll $3,r0,r0
1085: 1078 0002A86E 0d e000000004 effffff83b movl _cvlf_1_data+4(r0),_sgl_expected
1086: 1079 0002A879 # sgl_value_2 = 0x00000000; /* floating '0' */
1087: 1080 0002A879 4d effffff835 clrl _sgl_value_2
1088: 1081 0002A87F # /*
1089: 1082 0002A87F # * If LOOP ON ERROR is set, this is the loop for this subtest.
1090: 1083 0002A87F # * The force loop flag is set after the first error.
1091: 1084 0002A87F # */
1092: 1085 0002A87F # asm("_pipe6_8_lp1:");
1093: 1086 0002A87F _pipe6_8_lp1:
1094: 1087 0002A87F # asm("ldf _sgl_value_2"); /* load a floating '0' */
1095: 1088 0002A87F 06 effffff82f ldf _sgl_value_2
1096: 1089 0002A885 # asm("nop");
1097: 1090 0002A885 10 nop
1098: 1091 0002A886 # asm("nop");
1099: 1092 0002A886 10 nop
1100: 1093 0002A887 # asm("nop");
1101: 1094 0002A887 10 nop
1102: 1095 0002A888 # asm("addf _sgl_expected"); /* add the expected value */
1103: 1096 0002A888 c6 effffff826 addf _sgl_expected
1104: 1097 0002A88E # asm("nop");
1105: 1098 0002A88E 10 nop
1106: 1099 0002A88F # asm("nop");
1107: 1100 0002A88F 10 nop
1108: 1101 0002A890 # asm("nop");
1109: 1102 0002A890 10 nop
1110: 1103 0002A891 # asm("stf _sgl_st_acc"); /* store the result */
1111: 1104 0002A891 26 effffff81d stf _sgl_st_acc
1112: 1105 0002A897 # asm("nop");
1113: 1106 0002A897 10 nop
1114: 1107 0002A898 # asm("nop");
1115: 1108 0002A898 10 nop
1116: 1109 0002A899 # asm("nop");
1117: 1110 0002A899 10 nop
1118: 1111 0002A89A # asm("cvlf _sgl_value_1"); /* convert the int operand */
1119: 1112 0002A89A 76 effffff814 cvlf _sgl_value_1
1120: 1113 0002A8A0 # asm("nop");
1121: 1114 0002A8A0 10 nop
1122: 1115 0002A8A1 # asm("nop");
1123: 1116 0002A8A1 10 nop
1124: 1117 0002A8A2 # asm("nop");
1125: 1118 0002A8A2 10 nop
1126: 1119 0002A8A3 # asm("subf _sgl_value_2"); /* subtract a floating '0' */
1127: 1120 0002A8A3 d6 effffff80b subf _sgl_value_2
1128: 1121 0002A8A9 # asm("nop");
1129: 1122 0002A8A9 10 nop
1130: 1123 0002A8AA # asm("nop");
1131: 1124 0002A8AA 10 nop
1132: 1125 0002A8AB # asm("nop");
1133: 1126 0002A8AB 10 nop
1134: 1127 0002A8AC # asm("stf _sgl_value_6"); /* store the result */
1135: 1128 0002A8AC 26 effffff802 stf _sgl_value_6
1136: 1129 0002A8B2 # if( force_loop )
1137: 1130 0002A8B2 5d effffff7fc tstl _force_loop
1138: 1131 0002A8B8 31 02 jeql L332
1139: 1132 0002A8BA # asm("brb _pipe6_8_lp1");; /* loop on the error */
1140: 1133 0002A8BA 11 c3 brb _pipe6_8_lp1
1141: 1134 0002A8BC L332:
1142: 1135 0002A8BC # /*
1143: 1136 0002A8BC # * verify the results
1144: 1137 0002A8BC # */
1145: 1138 0002A8BC # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1146: 1139 0002A8BC # (sgl_value_6 != sgl_expected) )
1147: 1140 0002A8BC 1d effffff7f2 effffff7ed cmpl _sgl_st_acc,_sgl_expected
1148: 1141 0002A8C7 21 0d jneq L9992
1149: 1142 0002A8C9 1d effffff7e5 effffff7e0 cmpl _sgl_value_6,_sgl_expected
1150: 1143 0002A8D4 31 45 jeql L333
1151: 1144 0002A8D6 L9992:
1152: 1145 0002A8D6 # {
1153: 1146 0002A8D6 # errcnt++; /* bump the error count */
1154: 1147 0002A8D6 6d effffff7d8 incl _errcnt
1155: 1148 0002A8DC # if ( prt_error )
1156: 1149 0002A8DC 5d effffff7d2 tstl _prt_error
1157: 1150 0002A8E2 31 0d jeql L334
1158: 1151 0002A8E4 # print_pipe6_er("Cache Data, 3 NO-OPs");
1159: 1152 0002A8E4 .data 1
1160: 1153 00000e50 * L335:
1161: 1154 00000e50 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
1162: 3204E4F2D4F507300
1163: 1155 00000e65 * .text
1164: 1156 0002A8E4 dd 8f00000e50 pushl $L335
1165: 1157 0002A8EA fe 08 ef000003b7 callf $8,_print_pipe6_er
1166: 1158 0002A8F1 # if ( halt_flg ) /* halt on error? */
1167: 1159 0002A8F1 L334:
1168: 1160 0002A8F1 5d effffff7bd tstl _halt_flg
1169: 1161 0002A8F7 31 0d jeql L336
1170: 1162 0002A8F9 # pipe6_er_hlt( subtest );
1171: 1163 0002A8F9 dd effffff7b5 pushl _subtest
1172: 1164 0002A8FF fe 08 ef000004ea callf $8,_pipe6_er_hlt
1173: 1165 0002A906 # if ( loop_on_err ) {
1174: 1166 0002A906 L336:
1175: 1167 0002A906 5d effffff7a8 tstl _loop_on_err
1176: 1168 0002A90C 31 0d jeql L337
1177: 1169 0002A90E # force_loop = TRUE; /* set the force loop flag */
1178: 1170 0002A90E 0d 01 effffff79f movl $1,_force_loop
1179: 1171 0002A915 # asm("jmp _pipe6_8_lp1"); /* and loop */
1180: 1172 0002A915 71 efffffff64 jmp _pipe6_8_lp1
1181: 1173 0002A91B # }
1182: 1174 0002A91B # } /* end of compare error */
1183: 1175 0002A91B L337:
1184: 1176 0002A91B # } while( index++ < max_cvlf_1_index );
1185: 1177 0002A91B L333:
1186: 1178 0002A91B L330:
1187: 1179 0002A91B 0d effffff793 50 movl _index,r0
1188: 1180 0002A922 6d effffff78c incl _index
1189: 1181 0002A928 1d 50 effffff785 cmpl r0,_max_cvlf_1_index
1190: 1182 0002A92F 81 03 13 ff19 jlss L331
1191: 1183 0002A934 L329:
1192: 1184 0002A934 # } /* end of subtest 8 */
1193: 1185 0002A934 40 ret#2
1194: 1186 0002A935 .set L325,0x0
1195: 1187 0002A935 L327:
1196: 1188 0002A935 13 ff09 jbr L328
1197: 1189 0002A938 .data
1198: 1190 00000db8 * .text
1199: 1191 0002A938 .align 1
1200: 1192 0002A938 .globl _pipe6_9
1201: 1193 0002A938 _pipe6_9:
1202: 1194 0002A938 0000 .word L338
1203: 1195 0002A93A #
1204: 1196 0002A93A #
1205: 1197 0002A93A #
1206: 1198 0002A93A #
1207: 1199 0002A93A #
1208: 1200 0002A93A #
1209: 1201 0002A93A # /*****************************************************************************
1210: 1202 0002A93A # *
1211: 1203 0002A93A # * SUBTEST 9
1212: 1204 0002A93A # * data on the stack, no NO-OPs
1213: 1205 0002A93A # *
1214: 1206 0002A93A # *****************************************************************************/
1215: 1207 0002A93A # pipe6_9()
1216: 1208 0002A93A # {
1217: 1209 0002A93A 13 018b jbr L340
1218: 1210 0002A93D L341:
1219: 1211 0002A93D # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1220: 1212 0002A93D ed 6d effffff770 moval (r13),_pre_event_fp
1221: 1213 0002A944 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1222: 1214 0002A944 ed 6e effffff769 moval (r14),_pre_event_sp
1223: 1215 0002A94B # force_loop = FALSE; /* clear the force_loop flag */
1224: 1216 0002A94B 4d effffff763 clrl _force_loop
1225: 1217 0002A951 # index = 0;
1226: 1218 0002A951 4d effffff75d clrl _index
1227: 1219 0002A957 # do
1228: 1220 0002A957 L344:
1229: 1221 0002A957 # {
1230: 1222 0002A957 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1231: 1223 0002A957 0d effffff757 50 movl _index,r0
1232: 1224 0002A95E 48 03 50 50 shll $3,r0,r0
1233: 1225 0002A962 0d e000000000 effffff747 movl _cvlf_1_data(r0),_sgl_value_1
1234: 1226 0002A96D # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1235: 1227 0002A96D 0d effffff741 50 movl _index,r0
1236: 1228 0002A974 48 03 50 50 shll $3,r0,r0
1237: 1229 0002A978 0d e000000004 effffff731 movl _cvlf_1_data+4(r0),_sgl_expected
1238: 1230 0002A983 # sgl_value_2 = 0x00000000; /* floating '0' */
1239: 1231 0002A983 4d effffff72b clrl _sgl_value_2
1240: 1232 0002A989 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1241: 1233 0002A989 ed effffff725 effffff720 moval _pointer_data,_sgl_value_4
1242: 1234 0002A994 # /*
1243: 1235 0002A994 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1244: 1236 0002A994 # * The force loop flag is set after the first error.
1245: 1237 0002A994 # */
1246: 1238 0002A994 # asm("_pipe6_9_lp1:");
1247: 1239 0002A994 _pipe6_9_lp1:
1248: 1240 0002A994 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1249: 1241 0002A994 ed effffff71a 5e moval _pointer_data,r14
1250: 1242 0002A99B # asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */
1251: 1243 0002A99B 0d effffff713 7e movl _sgl_value_2,-(r14)
1252: 1244 0002A9A2 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1253: 1245 0002A9A2 0d effffff70c 7e movl _sgl_value_1,-(r14)
1254: 1246 0002A9A9 # asm("movl _sgl_expected,-(r14)"); /* push the expected result*/
1255: 1247 0002A9A9 0d effffff705 7e movl _sgl_expected,-(r14)
1256: 1248 0002A9B0 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */
1257: 1249 0002A9B0 0d effffff6fe 7e movl _sgl_value_2,-(r14)
1258: 1250 0002A9B7 # /*
1259: 1251 0002A9B7 # * now pop the data off the stack
1260: 1252 0002A9B7 # */
1261: 1253 0002A9B7 #
1262: 1254 0002A9B7 # asm("ldf (r14)+"); /* load the '0' value */
1263: 1255 0002A9B7 06 8e ldf (r14)+
1264: 1256 0002A9B9 # asm("addf (r14)+"); /* add the expected result */
1265: 1257 0002A9B9 c6 8e addf (r14)+
1266: 1258 0002A9BB # asm("stf r5"); /* store the result */
1267: 1259 0002A9BB 26 55 stf r5
1268: 1260 0002A9BD # asm("cvlf (r14)+"); /* convert the integer op */
1269: 1261 0002A9BD 76 8e cvlf (r14)+
1270: 1262 0002A9BF # asm("subf (r14)+"); /* subtract a floating '0' */
1271: 1263 0002A9BF d6 8e subf (r14)+
1272: 1264 0002A9C1 # asm("stf r6"); /* store the result */
1273: 1265 0002A9C1 26 56 stf r6
1274: 1266 0002A9C3 # if( force_loop )
1275: 1267 0002A9C3 5d effffff6eb tstl _force_loop
1276: 1268 0002A9C9 31 02 jeql L345
1277: 1269 0002A9CB # asm("brb _pipe6_9_lp1");; /* loop on the error */
1278: 1270 0002A9CB 11 c7 brb _pipe6_9_lp1
1279: 1271 0002A9CD L345:
1280: 1272 0002A9CD # /*
1281: 1273 0002A9CD # * verify the results
1282: 1274 0002A9CD # */
1283: 1275 0002A9CD # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1284: 1276 0002A9CD 0d 55 effffff6e0 movl r5,_sgl_st_acc
1285: 1277 0002A9D4 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1286: 1278 0002A9D4 0d 56 effffff6d9 movl r6,_sgl_value_6
1287: 1279 0002A9DB # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1288: 1280 0002A9DB ed 6e effffff6d2 moval (r14),_sgl_value_5
1289: 1281 0002A9E2 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1290: 1282 0002A9E2 # (sgl_value_6 != sgl_expected) ||
1291: 1283 0002A9E2 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1292: 1284 0002A9E2 1d effffff6cc effffff6c7 cmpl _sgl_st_acc,_sgl_expected
1293: 1285 0002A9ED 21 1d jneq L9991
1294: 1286 0002A9EF 1d effffff6bf effffff6ba cmpl _sgl_value_6,_sgl_expected
1295: 1287 0002A9FA 21 10 jneq L9991
1296: 1288 0002A9FC 1d effffff6b2 effffff6ad cmpl _sgl_value_5,_sgl_value_4
1297: 1289 0002AA07 21 03 13 0094 jeql L346
1298: 1290 0002AA0C L9991:
1299: 1291 0002AA0C # {
1300: 1292 0002AA0C # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1301: 1293 0002AA0C 0d effffff6a2 5d movl _pre_event_fp,r13
1302: 1294 0002AA13 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1303: 1295 0002AA13 0d effffff69b 5e movl _pre_event_sp,r14
1304: 1296 0002AA1A # errcnt++; /* bump the error count */
1305: 1297 0002AA1A 6d effffff694 incl _errcnt
1306: 1298 0002AA20 # if ( prt_error ) {
1307: 1299 0002AA20 5d effffff68e tstl _prt_error
1308: 1300 0002AA26 31 4e jeql L347
1309: 1301 0002AA28 # print_pipe4_er("POP data from the STACK");
1310: 1302 0002AA28 .data 1
1311: 1303 00000e65 * L349:
1312: 1304 00000e65 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
1313: D2074686520535441434B00
1314: 1305 00000e7d * .text
1315: 1306 0002AA28 dd 8f00000e65 pushl $L349
1316: 1307 0002AA2E fe 08 effffff67f callf $8,_print_pipe4_er
1317: 1308 0002AA35 # writes("final Stack Pointer = ");
1318: 1309 0002AA35 .data 1
1319: 1310 00000e7d * L350:
1320: 1311 00000e7d * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1321: 06F696E746572203D2000
1322: 1312 00000e94 * .text
1323: 1313 0002AA35 dd 8f00000e7d pushl $L350
1324: 1314 0002AA3B fe 08 effffff672 callf $8,_writes
1325: 1315 0002AA42 # write32h( sgl_value_5 );
1326: 1316 0002AA42 dd effffff66c pushl _sgl_value_5
1327: 1317 0002AA48 fe 08 effffff665 callf $8,_write32h
1328: 1318 0002AA4F # writes(", expected SP = ");
1329: 1319 0002AA4F .data 1
1330: 1320 00000e94 * L352:
1331: 1321 00000e94 * 2C20206578706563746564205 .ascii ", expected SP = \0"
1332: 350203D2000
1333: 1322 00000ea6 * .text
1334: 1323 0002AA4F dd 8f00000e94 pushl $L352
1335: 1324 0002AA55 fe 08 effffff658 callf $8,_writes
1336: 1325 0002AA5C # write32h( sgl_value_4 );
1337: 1326 0002AA5C dd effffff652 pushl _sgl_value_4
1338: 1327 0002AA62 fe 08 effffff64b callf $8,_write32h
1339: 1328 0002AA69 # writes("\n");
1340: 1329 0002AA69 .data 1
1341: 1330 00000ea6 * L353:
1342: 1331 00000ea6 * 0A00 .ascii "\12\0"
1343: 1332 00000ea8 * .text
1344: 1333 0002AA69 dd 8f00000ea6 pushl $L353
1345: 1334 0002AA6F fe 08 effffff63e callf $8,_writes
1346: 1335 0002AA76 # }
1347: 1336 0002AA76 # if ( halt_flg ) /* halt on error? */
1348: 1337 0002AA76 L347:
1349: 1338 0002AA76 5d effffff638 tstl _halt_flg
1350: 1339 0002AA7C 31 0d jeql L354
1351: 1340 0002AA7E # pipe6_er_hlt( subtest );
1352: 1341 0002AA7E dd effffff630 pushl _subtest
1353: 1342 0002AA84 fe 08 ef00000365 callf $8,_pipe6_er_hlt
1354: 1343 0002AA8B # if ( loop_on_err ) {
1355: 1344 0002AA8B L354:
1356: 1345 0002AA8B 5d effffff623 tstl _loop_on_err
1357: 1346 0002AA91 31 0d jeql L355
1358: 1347 0002AA93 # force_loop = TRUE; /* set the force loop flag */
1359: 1348 0002AA93 0d 01 effffff61a movl $1,_force_loop
1360: 1349 0002AA9A # asm("jmp _pipe6_9_lp1"); /* and loop */
1361: 1350 0002AA9A 71 effffffef4 jmp _pipe6_9_lp1
1362: 1351 0002AAA0 # }
1363: 1352 0002AAA0 # } /* end of compare error */
1364: 1353 0002AAA0 L355:
1365: 1354 0002AAA0 # } while( index++ < max_cvlf_1_index );
1366: 1355 0002AAA0 L346:
1367: 1356 0002AAA0 L343:
1368: 1357 0002AAA0 0d effffff60e 50 movl _index,r0
1369: 1358 0002AAA7 6d effffff607 incl _index
1370: 1359 0002AAAD 1d 50 effffff600 cmpl r0,_max_cvlf_1_index
1371: 1360 0002AAB4 81 03 13 fe9e jlss L344
1372: 1361 0002AAB9 L342:
1373: 1362 0002AAB9 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1374: 1363 0002AAB9 0d effffff5f5 5d movl _pre_event_fp,r13
1375: 1364 0002AAC0 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1376: 1365 0002AAC0 0d effffff5ee 5e movl _pre_event_sp,r14
1377: 1366 0002AAC7 # } /* end of subtest 9 */
1378: 1367 0002AAC7 40 ret#2
1379: 1368 0002AAC8 .set L338,0x0
1380: 1369 0002AAC8 L340:
1381: 1370 0002AAC8 13 fe72 jbr L341
1382: 1371 0002AACB .data
1383: 1372 00000db8 * .text
1384: 1373 0002AACB 00 .align 1
1385: 1374 0002AACC .globl _pipe6_10
1386: 1375 0002AACC _pipe6_10:
1387: 1376 0002AACC 0000 .word L356
1388: 1377 0002AACE #
1389: 1378 0002AACE #
1390: 1379 0002AACE #
1391: 1380 0002AACE #
1392: 1381 0002AACE #
1393: 1382 0002AACE #
1394: 1383 0002AACE # /******************************************************************************
1395: 1384 0002AACE # *
1396: 1385 0002AACE # * SUBTEST 10
1397: 1386 0002AACE # * get data via indexed FRAME pointer
1398: 1387 0002AACE # *
1399: 1388 0002AACE # * ADDR INDEX DATA
1400: 1389 0002AACE # * pointer_data 4 <the 1st STF result goes here>
1401: 1390 0002AACE # * pointer_data-4 3 <the 2nd STF result goes here>
1402: 1391 0002AACE # * pointer_data-8 2 <integer operand>
1403: 1392 0002AACE # * pointer_data-12 1 <floating '0'>
1404: 1393 0002AACE # * pointer_data-16 0 <floating operand> ( point FP here )
1405: 1394 0002AACE # *
1406: 1395 0002AACE # ******************************************************************************/
1407: 1396 0002AACE # pipe6_10()
1408: 1397 0002AACE # {
1409: 1398 0002AACE 13 01d3 jbr L358
1410: 1399 0002AAD1 L359:
1411: 1400 0002AAD1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1412: 1401 0002AAD1 ed 6d effffff5dc moval (r13),_pre_event_fp
1413: 1402 0002AAD8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1414: 1403 0002AAD8 ed 6e effffff5d5 moval (r14),_pre_event_sp
1415: 1404 0002AADF # force_loop = FALSE; /* clear the force_loop flag */
1416: 1405 0002AADF 4d effffff5cf clrl _force_loop
1417: 1406 0002AAE5 # index = 0;
1418: 1407 0002AAE5 4d effffff5c9 clrl _index
1419: 1408 0002AAEB # do
1420: 1409 0002AAEB L362:
1421: 1410 0002AAEB # {
1422: 1411 0002AAEB # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1423: 1412 0002AAEB 0d effffff5c3 50 movl _index,r0
1424: 1413 0002AAF2 48 03 50 50 shll $3,r0,r0
1425: 1414 0002AAF6 0d e000000000 effffff5b3 movl _cvlf_1_data(r0),_sgl_value_1
1426: 1415 0002AB01 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1427: 1416 0002AB01 0d effffff5ad 50 movl _index,r0
1428: 1417 0002AB08 48 03 50 50 shll $3,r0,r0
1429: 1418 0002AB0C 0d e000000004 effffff59d movl _cvlf_1_data+4(r0),_sgl_expected
1430: 1419 0002AB17 # sgl_value_2 = 0x00000000; /* floating '0' */
1431: 1420 0002AB17 4d effffff597 clrl _sgl_value_2
1432: 1421 0002AB1D # asm("moval _pointer_data,_sgl_value_4"); /* get store data's addr */
1433: 1422 0002AB1D ed effffff591 effffff58c moval _pointer_data,_sgl_value_4
1434: 1423 0002AB28 # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1435: 1424 0002AB28 2c 08 effffff585 subl2 $8,_sgl_value_4
1436: 1425 0002AB2F # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the integer op. */
1437: 1426 0002AB2F 0d effffff57f fffffff57a movl _sgl_value_1,*_sgl_value_4
1438: 1427 0002AB3A # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1439: 1428 0002AB3A 2c 04 effffff573 subl2 $4,_sgl_value_4
1440: 1429 0002AB41 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '0' */
1441: 1430 0002AB41 0d effffff56d fffffff568 movl _sgl_value_2,*_sgl_value_4
1442: 1431 0002AB4C # sgl_value_4 -= 4; /* get FRAME PTR address */
1443: 1432 0002AB4C 2c 04 effffff561 subl2 $4,_sgl_value_4
1444: 1433 0002AB53 # asm("movl _sgl_expected,*_sgl_value_4"); /* set the floating op. */
1445: 1434 0002AB53 0d effffff55b fffffff556 movl _sgl_expected,*_sgl_value_4
1446: 1435 0002AB5E # /*
1447: 1436 0002AB5E # * If LOOP ON ERROR is set, this is the loop for this subtest.
1448: 1437 0002AB5E # * The force loop flag is set after the first error.
1449: 1438 0002AB5E # */
1450: 1439 0002AB5E # asm("_pipe6_10_lp1:");
1451: 1440 0002AB5E _pipe6_10_lp1:
1452: 1441 0002AB5E # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1453: 1442 0002AB5E 0d effffff550 5d movl _sgl_value_4,r13
1454: 1443 0002AB65 # asm("movl $1,r1"); /* r1 index = 1 ( '0' ) */
1455: 1444 0002AB65 0d 01 51 movl $1,r1
1456: 1445 0002AB68 # asm("movl $2,r2"); /* r2 index = 2 (int. op.) */
1457: 1446 0002AB68 0d 02 52 movl $2,r2
1458: 1447 0002AB6B # asm("movl $3,r3"); /* r3 index = 3 (2nd store) */
1459: 1448 0002AB6B 0d 03 53 movl $3,r3
1460: 1449 0002AB6E # asm("movl $4,r4"); /* r4 index = 4 (1st store) */
1461: 1450 0002AB6E 0d 04 54 movl $4,r4
1462: 1451 0002AB71 # asm("clrl r5"); /* r5 index = 0 (sgl. op.) */
1463: 1452 0002AB71 4d 55 clrl r5
1464: 1453 0002AB73 # asm("ldf (r13)[r1]"); /* load a '0' (indx=1) */
1465: 1454 0002AB73 06 416d ldf (r13)[r1]
1466: 1455 0002AB76 # asm("addf (r13)[r5]"); /* add the operand (indx=0) */
1467: 1456 0002AB76 c6 456d addf (r13)[r5]
1468: 1457 0002AB79 # asm("stf (r13)[r4]"); /* 1st store (indx=4) */
1469: 1458 0002AB79 26 446d stf (r13)[r4]
1470: 1459 0002AB7C # asm("cvlf (r13)[r2]"); /* convert the int (indx=2) */
1471: 1460 0002AB7C 76 426d cvlf (r13)[r2]
1472: 1461 0002AB7F # asm("subf (r13)[r1]"); /* subtract a '0' (indx=1) */
1473: 1462 0002AB7F d6 416d subf (r13)[r1]
1474: 1463 0002AB82 # asm("stf (r13)[r3]"); /* 2nd store (indx=3) */
1475: 1464 0002AB82 26 436d stf (r13)[r3]
1476: 1465 0002AB85 # if( force_loop )
1477: 1466 0002AB85 5d effffff529 tstl _force_loop
1478: 1467 0002AB8B 31 02 jeql L363
1479: 1468 0002AB8D # asm("brb _pipe6_10_lp1");; /* loop on the error */
1480: 1469 0002AB8D 11 cf brb _pipe6_10_lp1
1481: 1470 0002AB8F L363:
1482: 1471 0002AB8F # /*
1483: 1472 0002AB8F # * verify the results
1484: 1473 0002AB8F # */
1485: 1474 0002AB8F # sgl_st_acc = pointer_data; /* save 1st stored value */
1486: 1475 0002AB8F 0d effffff51f effffff51a movl _pointer_data,_sgl_st_acc
1487: 1476 0002AB9A # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1488: 1477 0002AB9A ed effffff514 effffff50f moval _pointer_data,_sgl_value_5
1489: 1478 0002ABA5 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1490: 1479 0002ABA5 2c 04 effffff508 subl2 $4,_sgl_value_5
1491: 1480 0002ABAC # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1492: 1481 0002ABAC 0d fffffff502 effffff4fd movl *_sgl_value_5,_sgl_value_6
1493: 1482 0002ABB7 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1494: 1483 0002ABB7 ed 6d effffff4f6 moval (r13),_sgl_value_5
1495: 1484 0002ABBE # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1496: 1485 0002ABBE # (sgl_value_6 != sgl_expected) ||
1497: 1486 0002ABBE # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1498: 1487 0002ABBE 1d effffff4f0 effffff4eb cmpl _sgl_st_acc,_sgl_expected
1499: 1488 0002ABC9 21 1d jneq L9990
1500: 1489 0002ABCB 1d effffff4e3 effffff4de cmpl _sgl_value_6,_sgl_expected
1501: 1490 0002ABD6 21 10 jneq L9990
1502: 1491 0002ABD8 1d effffff4d6 effffff4d1 cmpl _sgl_value_5,_sgl_value_4
1503: 1492 0002ABE3 21 03 13 0094 jeql L364
1504: 1493 0002ABE8 L9990:
1505: 1494 0002ABE8 # {
1506: 1495 0002ABE8 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1507: 1496 0002ABE8 0d effffff4c6 5d movl _pre_event_fp,r13
1508: 1497 0002ABEF # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1509: 1498 0002ABEF 0d effffff4bf 5e movl _pre_event_sp,r14
1510: 1499 0002ABF6 # errcnt++; /* bump the error count */
1511: 1500 0002ABF6 6d effffff4b8 incl _errcnt
1512: 1501 0002ABFC # if ( prt_error ) {
1513: 1502 0002ABFC 5d effffff4b2 tstl _prt_error
1514: 1503 0002AC02 31 4e jeql L365
1515: 1504 0002AC04 # print_pipe6_er("indexed FP addressing");
1516: 1505 0002AC04 .data 1
1517: 1506 00000ea8 * L366:
1518: 1507 00000ea8 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1519: 46472657373696E6700
1520: 1508 00000ebe * .text
1521: 1509 0002AC04 dd 8f00000ea8 pushl $L366
1522: 1510 0002AC0A fe 08 ef00000097 callf $8,_print_pipe6_er
1523: 1511 0002AC11 # writes("final Frame Pointer = ");
1524: 1512 0002AC11 .data 1
1525: 1513 00000ebe * L367:
1526: 1514 00000ebe * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1527: 06F696E746572203D2000
1528: 1515 00000ed5 * .text
1529: 1516 0002AC11 dd 8f00000ebe pushl $L367
1530: 1517 0002AC17 fe 08 effffff496 callf $8,_writes
1531: 1518 0002AC1E # writeh( sgl_value_5 );
1532: 1519 0002AC1E dd effffff490 pushl _sgl_value_5
1533: 1520 0002AC24 fe 08 effffff489 callf $8,_writeh
1534: 1521 0002AC2B # writes(", expected FP = ");
1535: 1522 0002AC2B .data 1
1536: 1523 00000ed5 * L369:
1537: 1524 00000ed5 * 2C20206578706563746564204 .ascii ", expected FP = \0"
1538: 650203D2000
1539: 1525 00000ee7 * .text
1540: 1526 0002AC2B dd 8f00000ed5 pushl $L369
1541: 1527 0002AC31 fe 08 effffff47c callf $8,_writes
1542: 1528 0002AC38 # writeh( sgl_value_4 );
1543: 1529 0002AC38 dd effffff476 pushl _sgl_value_4
1544: 1530 0002AC3E fe 08 effffff46f callf $8,_writeh
1545: 1531 0002AC45 # writes("\n");
1546: 1532 0002AC45 .data 1
1547: 1533 00000ee7 * L370:
1548: 1534 00000ee7 * 0A00 .ascii "\12\0"
1549: 1535 00000ee9 * .text
1550: 1536 0002AC45 dd 8f00000ee7 pushl $L370
1551: 1537 0002AC4B fe 08 effffff462 callf $8,_writes
1552: 1538 0002AC52 # }
1553: 1539 0002AC52 # if ( halt_flg ) /* halt on error? */
1554: 1540 0002AC52 L365:
1555: 1541 0002AC52 5d effffff45c tstl _halt_flg
1556: 1542 0002AC58 31 0d jeql L371
1557: 1543 0002AC5A # pipe6_er_hlt( subtest );
1558: 1544 0002AC5A dd effffff454 pushl _subtest
1559: 1545 0002AC60 fe 08 ef00000189 callf $8,_pipe6_er_hlt
1560: 1546 0002AC67 # if ( loop_on_err ) {
1561: 1547 0002AC67 L371:
1562: 1548 0002AC67 5d effffff447 tstl _loop_on_err
1563: 1549 0002AC6D 31 0d jeql L372
1564: 1550 0002AC6F # force_loop = TRUE; /* set the force loop flag */
1565: 1551 0002AC6F 0d 01 effffff43e movl $1,_force_loop
1566: 1552 0002AC76 # asm("jmp _pipe6_10_lp1"); /* and loop */
1567: 1553 0002AC76 71 effffffee2 jmp _pipe6_10_lp1
1568: 1554 0002AC7C # }
1569: 1555 0002AC7C # } /* end of compare error */
1570: 1556 0002AC7C L372:
1571: 1557 0002AC7C # } while( index++ < max_cvlf_1_index );
1572: 1558 0002AC7C L364:
1573: 1559 0002AC7C L361:
1574: 1560 0002AC7C 0d effffff432 50 movl _index,r0
1575: 1561 0002AC83 6d effffff42b incl _index
1576: 1562 0002AC89 1d 50 effffff424 cmpl r0,_max_cvlf_1_index
1577: 1563 0002AC90 81 03 13 fe56 jlss L362
1578: 1564 0002AC95 L360:
1579: 1565 0002AC95 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1580: 1566 0002AC95 0d effffff419 5d movl _pre_event_fp,r13
1581: 1567 0002AC9C # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1582: 1568 0002AC9C 0d effffff412 5e movl _pre_event_sp,r14
1583: 1569 0002ACA3 # } /* end of subtest 10 */
1584: 1570 0002ACA3 40 ret#2
1585: 1571 0002ACA4 .set L356,0x0
1586: 1572 0002ACA4 L358:
1587: 1573 0002ACA4 13 fe2a jbr L359
1588: 1574 0002ACA7 .data
1589: 1575 00000db8 * .text
1590: 1576 0002ACA7 00 .align 1
1591: 1577 0002ACA8 .globl _print_pipe6_er
1592: 1578 0002ACA8 _print_pipe6_er:
1593: 1579 0002ACA8 0000 .word L373
1594: 1580 0002ACAA #
1595: 1581 0002ACAA #
1596: 1582 0002ACAA # /******************************************************************************
1597: 1583 0002ACAA # *
1598: 1584 0002ACAA # *
1599: 1585 0002ACAA # * print an error in the following form
1600: 1586 0002ACAA # *
1601: 1587 0002ACAA # * operand 1 = xxxxxxxx, 1st store = xxxxxxxx, data index = dd
1602: 1588 0002ACAA # * operand 2 = xxxxxxxx, 2nd store = xxxxxxxx
1603: 1589 0002ACAA # * expected Acc = xxxxxxxx
1604: 1590 0002ACAA # *
1605: 1591 0002ACAA # ******************************************************************************/
1606: 1592 0002ACAA # print_pipe6_er(msg)
1607: 1593 0002ACAA # char *msg;
1608: 1594 0002ACAA # {
1609: 1595 0002ACAA 13 0140 jbr L375
1610: 1596 0002ACAD L376:
1611: 1597 0002ACAD # writes("\n"); /* start a new print line */
1612: 1598 0002ACAD .data 1
1613: 1599 00000ee9 * L377:
1614: 1600 00000ee9 * 0A00 .ascii "\12\0"
1615: 1601 00000eeb * .text
1616: 1602 0002ACAD dd 8f00000ee9 pushl $L377
1617: 1603 0002ACB3 fe 08 effffff3fa callf $8,_writes
1618: 1604 0002ACBA # writes("cycle: ");
1619: 1605 0002ACBA .data 1
1620: 1606 00000eeb * L378:
1621: 1607 00000eeb * 6379636C653A2000 .ascii "cycle: \0"
1622: 1608 00000ef3 * .text
1623: 1609 0002ACBA dd 8f00000eeb pushl $L378
1624: 1610 0002ACC0 fe 08 effffff3ed callf $8,_writes
1625: 1611 0002ACC7 # writed( cycle );
1626: 1612 0002ACC7 dd effffff3e7 pushl _cycle
1627: 1613 0002ACCD fe 08 effffff3e0 callf $8,_writed
1628: 1614 0002ACD4 # writes(" test ");
1629: 1615 0002ACD4 .data 1
1630: 1616 00000ef3 * L380:
1631: 1617 00000ef3 * 20746573742000 .ascii " test \0"
1632: 1618 00000efa * .text
1633: 1619 0002ACD4 dd 8f00000ef3 pushl $L380
1634: 1620 0002ACDA fe 08 effffff3d3 callf $8,_writes
1635: 1621 0002ACE1 # writed( test_no );
1636: 1622 0002ACE1 dd effffff3cd pushl _test_no
1637: 1623 0002ACE7 fe 08 effffff3c6 callf $8,_writed
1638: 1624 0002ACEE # writes(" (Pipe 6), subtest ");
1639: 1625 0002ACEE .data 1
1640: 1626 00000efa * L381:
1641: 1627 00000efa * 202028506970652036292C207 .ascii " (Pipe 6), subtest \0"
1642: 37562746573742000
1643: 1628 00000f0f * .text
1644: 1629 0002ACEE dd 8f00000efa pushl $L381
1645: 1630 0002ACF4 fe 08 effffff3b9 callf $8,_writes
1646: 1631 0002ACFB # writed( subtest );
1647: 1632 0002ACFB dd effffff3b3 pushl _subtest
1648: 1633 0002AD01 fe 08 effffff3ac callf $8,_writed
1649: 1634 0002AD08 # writes(" error - ");
1650: 1635 0002AD08 .data 1
1651: 1636 00000f0f * L382:
1652: 1637 00000f0f * 206572726F72202D2000 .ascii " error - \0"
1653: 1638 00000f19 * .text
1654: 1639 0002AD08 dd 8f00000f0f pushl $L382
1655: 1640 0002AD0E fe 08 effffff39f callf $8,_writes
1656: 1641 0002AD15 # writes( msg );
1657: 1642 0002AD15 dd ad04 pushl 4(fp)
1658: 1643 0002AD18 fe 08 effffff395 callf $8,_writes
1659: 1644 0002AD1F # writec('\n');
1660: 1645 0002AD1F dd 0a pushl $10
1661: 1646 0002AD21 fe 08 effffff38c callf $8,_writec
1662: 1647 0002AD28 # writes(" LDF(0.0), ADDF(op1), STF, CVLF(op2), SUBF(0.0), STF\n");
1663: 1648 0002AD28 .data 1
1664: 1649 00000f19 * L384:
1665: 1650 00000f19 * 20204C444628302E30292C204 .ascii " LDF(0.0), ADDF(op1), STF, CVLF(op2), SUBF(0.0), STF\12\0"
1666: 1444446286F7031292C205354
1667: 462C2043564C46286F7032292
1668: C205355424628302E30292C20
1669: 5354460A00
1670: 1651 00000f50 * .text
1671: 1652 0002AD28 dd 8f00000f19 pushl $L384
1672: 1653 0002AD2E fe 08 effffff37f callf $8,_writes
1673: 1654 0002AD35 # writes("operand 1 = ");
1674: 1655 0002AD35 .data 1
1675: 1656 00000f50 * L385:
1676: 1657 00000f50 * 6F706572616E642031203D200 .ascii "operand 1 = \0"
1677: 0
1678: 1658 00000f5d * .text
1679: 1659 0002AD35 dd 8f00000f50 pushl $L385
1680: 1660 0002AD3B fe 08 effffff372 callf $8,_writes
1681: 1661 0002AD42 # write32h( sgl_expected );
1682: 1662 0002AD42 dd effffff36c pushl _sgl_expected
1683: 1663 0002AD48 fe 08 effffff365 callf $8,_write32h
1684: 1664 0002AD4F # writes(", 1st store = ");
1685: 1665 0002AD4F .data 1
1686: 1666 00000f5d * L386:
1687: 1667 00000f5d * 2C2020203173742073746F726 .ascii ", 1st store = \0"
1688: 5203D2000
1689: 1668 00000f6e * .text
1690: 1669 0002AD4F dd 8f00000f5d pushl $L386
1691: 1670 0002AD55 fe 08 effffff358 callf $8,_writes
1692: 1671 0002AD5C # write32h( sgl_st_acc );
1693: 1672 0002AD5C dd effffff352 pushl _sgl_st_acc
1694: 1673 0002AD62 fe 08 effffff34b callf $8,_write32h
1695: 1674 0002AD69 # writes(", data index = ");
1696: 1675 0002AD69 .data 1
1697: 1676 00000f6e * L387:
1698: 1677 00000f6e * 2C2020206461746120696E646 .ascii ", data index = \0"
1699: 578203D2000
1700: 1678 00000f80 * .text
1701: 1679 0002AD69 dd 8f00000f6e pushl $L387
1702: 1680 0002AD6F fe 08 effffff33e callf $8,_writes
1703: 1681 0002AD76 # writed( index );
1704: 1682 0002AD76 dd effffff338 pushl _index
1705: 1683 0002AD7C fe 08 effffff331 callf $8,_writed
1706: 1684 0002AD83 # writec('\n');
1707: 1685 0002AD83 dd 0a pushl $10
1708: 1686 0002AD85 fe 08 effffff328 callf $8,_writec
1709: 1687 0002AD8C # writes("operand 2 = ");
1710: 1688 0002AD8C .data 1
1711: 1689 00000f80 * L388:
1712: 1690 00000f80 * 6F706572616E642032203D200 .ascii "operand 2 = \0"
1713: 0
1714: 1691 00000f8d * .text
1715: 1692 0002AD8C dd 8f00000f80 pushl $L388
1716: 1693 0002AD92 fe 08 effffff31b callf $8,_writes
1717: 1694 0002AD99 # write32h( sgl_value_1 );
1718: 1695 0002AD99 dd effffff315 pushl _sgl_value_1
1719: 1696 0002AD9F fe 08 effffff30e callf $8,_write32h
1720: 1697 0002ADA6 # writes(", 2nd store = ");
1721: 1698 0002ADA6 .data 1
1722: 1699 00000f8d * L389:
1723: 1700 00000f8d * 2C202020326E642073746F726 .ascii ", 2nd store = \0"
1724: 5203D2000
1725: 1701 00000f9e * .text
1726: 1702 0002ADA6 dd 8f00000f8d pushl $L389
1727: 1703 0002ADAC fe 08 effffff301 callf $8,_writes
1728: 1704 0002ADB3 # write32h( sgl_value_6 );
1729: 1705 0002ADB3 dd effffff2fb pushl _sgl_value_6
1730: 1706 0002ADB9 fe 08 effffff2f4 callf $8,_write32h
1731: 1707 0002ADC0 # writec('\n');
1732: 1708 0002ADC0 dd 0a pushl $10
1733: 1709 0002ADC2 fe 08 effffff2eb callf $8,_writec
1734: 1710 0002ADC9 # writes(" expected Acc = ");
1735: 1711 0002ADC9 .data 1
1736: 1712 00000f9e * L390:
1737: 1713 00000f9e * 2020202020202020202020202 .ascii " expected Acc = \0"
1738: 0202020202020202065787065
1739: 6374656420416363203D2000
1740: 1714 00000fc3 * .text
1741: 1715 0002ADC9 dd 8f00000f9e pushl $L390
1742: 1716 0002ADCF fe 08 effffff2de callf $8,_writes
1743: 1717 0002ADD6 # write32h( sgl_expected );
1744: 1718 0002ADD6 dd effffff2d8 pushl _sgl_expected
1745: 1719 0002ADDC fe 08 effffff2d1 callf $8,_write32h
1746: 1720 0002ADE3 # writec('\n');
1747: 1721 0002ADE3 dd 0a pushl $10
1748: 1722 0002ADE5 fe 08 effffff2c8 callf $8,_writec
1749: 1723 0002ADEC # }
1750: 1724 0002ADEC 40 ret#2
1751: 1725 0002ADED .set L373,0x0
1752: 1726 0002ADED L375:
1753: 1727 0002ADED 13 febd jbr L376
1754: 1728 0002ADF0 .data
1755: 1729 00000db8 * .text
1756: 1730 0002ADF0 .align 1
1757: 1731 0002ADF0 .globl _pipe6_er_hlt
1758: 1732 0002ADF0 _pipe6_er_hlt:
1759: 1733 0002ADF0 0000 .word L391
1760: 1734 0002ADF2 #
1761: 1735 0002ADF2 #
1762: 1736 0002ADF2 #
1763: 1737 0002ADF2 #
1764: 1738 0002ADF2 #
1765: 1739 0002ADF2 # /******************************************************************************
1766: 1740 0002ADF2 # *
1767: 1741 0002ADF2 # * HALT ON ERROR ROUTINE
1768: 1742 0002ADF2 # *
1769: 1743 0002ADF2 # * halt with the necessary information saved in the registers
1770: 1744 0002ADF2 # *
1771: 1745 0002ADF2 # ******************************************************************************/
1772: 1746 0002ADF2 # pipe6_er_hlt( subtest )
1773: 1747 0002ADF2 # int subtest;
1774: 1748 0002ADF2 # {
1775: 1749 0002ADF2 11 75 jbr L393
1776: 1750 0002ADF4 L394:
1777: 1751 0002ADF4 # asm("movl _test_no,r0"); /* r0 = test number */
1778: 1752 0002ADF4 0d effffff2ba 50 movl _test_no,r0
1779: 1753 0002ADFB # asm("movl _subtest,r1"); /* r1 = subtest number */
1780: 1754 0002ADFB 0d effffff2b3 51 movl _subtest,r1
1781: 1755 0002AE02 # asm("movl $1,r2"); /* r2 = error code */
1782: 1756 0002AE02 0d 01 52 movl $1,r2
1783: 1757 0002AE05 # asm("movl _cycle,r3"); /* r3 = cycle count */
1784: 1758 0002AE05 0d effffff2a9 53 movl _cycle,r3
1785: 1759 0002AE0C # asm("movl _sgl_expected,r4"); /* r4 = 1st operand */
1786: 1760 0002AE0C 0d effffff2a2 54 movl _sgl_expected,r4
1787: 1761 0002AE13 # asm("movl _sgl_value_1,r5"); /* r5 = 2nd operand */
1788: 1762 0002AE13 0d effffff29b 55 movl _sgl_value_1,r5
1789: 1763 0002AE1A # asm("movl _sgl_st_acc,r6"); /* r6 = 1st word stored */
1790: 1764 0002AE1A 0d effffff294 56 movl _sgl_st_acc,r6
1791: 1765 0002AE21 # asm("movl _sgl_value_6,r7"); /* r6 = 2nd word stored */
1792: 1766 0002AE21 0d effffff28d 57 movl _sgl_value_6,r7
1793: 1767 0002AE28 # asm("movl _sgl_expected,r8"); /* r8 = sgl expected */
1794: 1768 0002AE28 0d effffff286 58 movl _sgl_expected,r8
1795: 1769 0002AE2F # asm("movl _index,r9"); /* r9 = data index */
1796: 1770 0002AE2F 0d effffff27f 59 movl _index,r9
1797: 1771 0002AE36 # asm("movl _sgl_value_2,r10"); /* r10 = floating zero */
1798: 1772 0002AE36 0d effffff278 5a movl _sgl_value_2,r10
1799: 1773 0002AE3D # if( subtest == 9 ) {
1800: 1774 0002AE3D 1d ad04 09 cmpl 4(fp),$9
1801: 1775 0002AE41 21 10 jneq L395
1802: 1776 0002AE43 # asm("movl _sgl_value_5,r11"); /* r11= final SP value */
1803: 1777 0002AE43 0d effffff26b 5b movl _sgl_value_5,r11
1804: 1778 0002AE4A # asm("movl _sgl_value_4,r12"); /* r12= expected SP value */
1805: 1779 0002AE4A 0d effffff264 5c movl _sgl_value_4,r12
1806: 1780 0002AE51 # } else
1807: 1781 0002AE51 11 14 jbr L396
1808: 1782 0002AE53 L395:
1809: 1783 0002AE53 # if( subtest == 10 ) {
1810: 1784 0002AE53 1d ad04 0a cmpl 4(fp),$10
1811: 1785 0002AE57 21 0e jneq L397
1812: 1786 0002AE59 # asm("movl _sgl_value_5,r11"); /* r11= final FP value */
1813: 1787 0002AE59 0d effffff255 5b movl _sgl_value_5,r11
1814: 1788 0002AE60 # asm("movl _sgl_value_4,r12"); /* r12= expected FP value */
1815: 1789 0002AE60 0d effffff24e 5c movl _sgl_value_4,r12
1816: 1790 0002AE67 # };
1817: 1791 0002AE67 L397:
1818: 1792 0002AE67 L396:
1819: 1793 0002AE67 # asm(".globl _pipe6_1_hlt");
1820: 1794 0002AE67 .globl _pipe6_1_hlt
1821: 1795 0002AE67 # asm("_pipe6_1_hlt:"); /* PC after the halt */
1822: 1796 0002AE67 _pipe6_1_hlt:
1823: 1797 0002AE67 # asm("halt"); /* HALT ... */
1824: 1798 0002AE67 00 halt
1825: 1799 0002AE68 # } /* end of halt on error */
1826: 1800 0002AE68 40 ret#2
1827: 1801 0002AE69 .set L391,0x0
1828: 1802 0002AE69 L393:
1829: 1803 0002AE69 11 89 jbr L394
1830: 1804 0002AE6B .data
1831: 1804 00054F1F .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.