![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe3.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 pipe3.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
Power 6/32 Unix version 1.21
1 00000000 LL0:
2 00000000 .data
3 00000ce8 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_3
6 00000000 _pipe_3:
7 00027948 0000 .word L215
8 0002794A # #include "fpp_defs.h"
9 0002794A #
10 0002794A #
11 0002794A # /*****************************************************************************
12 0002794A # *
13 0002794A # * PIPELINE TEST #3 MONITOR
14 0002794A # *
15 0002794A # * This test will do:
16 0002794A # *
17 0002794A # * CVLF(x), STF, MULF(1), STF
18 0002794A # *
19 0002794A # * where x is the fmacro1 CVLF data. This test verifies that we can keep
20 0002794A # * using data after we store it.
21 0002794A # *****************************************************************************/
22 0002794A # pipe_3()
23 0002794A # {
24 0002794A 13 00a8 jbr L217
25 0002794D L218:
26 0002794D # asm(".globl _pipeline_3_t");
27 0002794D .globl _pipeline_3_t
28 0002794D # asm("_pipeline_3_t:"); /* entry address */
29 0002794D _pipeline_3_t:
30 0002794D # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
31 0002794D 1d effffffff5 01 cmpl _cycle,$1
32 00027954 21 15 jneq L219
33 00027956 5d efffffffec tstl _prt_hdrs
34 0002795C 31 0d jeql L219
35 0002795E # {
36 0002795E # writes(" PIPE_3 ");
37 0002795E .data 1
38 00000ce8 * L221:
39 00000ce8 * 20504950455F332000 .ascii " PIPE_3 \0"
40 00000cf1 * .text
41 0002795E dd 8f00000ce8 pushl $L221
42 00027964 fe 08 efffffffdd callf $8,_writes
43 0002796B # }
44 0002796B # subtest = 1;
45 0002796B L219:
46 0002796B 0d 01 efffffffd6 movl $1,_subtest
47 00027972 # pipe3_1(); /* data in REGs, no NOPs */
48 00027972 fe 04 ef0000007f callf $4,_pipe3_1
49 00027979 # subtest++; /* increment the subtest */
50 00027979 6d efffffffc9 incl _subtest
51 0002797F # pipe3_2(); /* data in REGs, 1 NOP */
52 0002797F fe 04 ef00000162 callf $4,_pipe3_2
53 00027986 # subtest++; /* increment the subtest */
54 00027986 6d efffffffbc incl _subtest
55 0002798C # pipe3_3(); /* data in REGs, 2 NOPs */
56 0002798C fe 04 ef00000247 callf $4,_pipe3_3
57 00027993 # subtest++; /* increment the subtest */
58 00027993 6d efffffffaf incl _subtest
59 00027999 # pipe3_4(); /* data in REGs, 3 NOPs */
60 00027999 fe 04 ef00000330 callf $4,_pipe3_4
61 000279A0 # subtest++; /* increment the subtest */
62 000279A0 6d efffffffa2 incl _subtest
63 000279A6 # pipe3_5(); /* data in CACHE, no NOPs */
64 000279A6 fe 04 ef0000041b callf $4,_pipe3_5
65 000279AD # subtest++; /* increment the subtest */
66 000279AD 6d efffffff95 incl _subtest
67 000279B3 # pipe3_6(); /* data in CACHE, 1 NOP */
68 000279B3 fe 04 ef000004f2 callf $4,_pipe3_6
69 000279BA # subtest++; /* increment the subtest */
70 000279BA 6d efffffff88 incl _subtest
71 000279C0 # pipe3_7(); /* data in CACHE, 2 NOPs */
72 000279C0 fe 04 ef000005cb callf $4,_pipe3_7
73 000279C7 # subtest++; /* increment the subtest */
74 000279C7 6d efffffff7b incl _subtest
75 000279CD # pipe3_8(); /* data in CACHE, 3 NOPs */
76 000279CD fe 04 ef000006a8 callf $4,_pipe3_8
77 000279D4 # subtest++; /* increment the subtest */
78 000279D4 6d efffffff6e incl _subtest
79 000279DA # pipe3_9(); /* data on STACK, no NOPs */
80 000279DA fe 04 ef00000787 callf $4,_pipe3_9
81 000279E1 # subtest++; /* increment the subtest */
82 000279E1 6d efffffff61 incl _subtest
83 000279E7 # pipe3_10(); /* data via FP no NOPs */
84 000279E7 fe 04 ef000008fe callf $4,_pipe3_10
85 000279EE # asm("jmp *return"); /* return to the test monitor */
86 000279EE 71 ffffffff54 jmp *return
87 000279F4 # }
88 000279F4 40 ret#2
89 000279F5 .set L215,0x0
90 000279F5 L217:
91 000279F5 13 ff55 jbr L218
92 000279F8 .data
93 00000ce8 * .text
94 000279F8 .align 1
95 000279F8 .globl _pipe3_1
96 000279F8 _pipe3_1:
97 000279F8 0000 .word L232
98 000279FA #
99 000279FA #
100 000279FA #
101 000279FA #
102 000279FA #
103 000279FA #
104 000279FA # /************************************************************************
105 000279FA # *
106 000279FA # * SUBTEST 1
107 000279FA # * data in registers, no NO-OPs
108 000279FA # *
109 000279FA # ************************************************************************/
110 000279FA # pipe3_1()
111 000279FA # {
112 000279FA 13 00e7 jbr L234
113 000279FD L235:
114 000279FD # force_loop = FALSE; /* clear force_loop flag */
115 000279FD 4d efffffff45 clrl _force_loop
116 00027A03 # index = 0;
117 00027A03 4d efffffff3f clrl _index
118 00027A09 # do
119 00027A09 L238:
120 00027A09 # {
121 00027A09 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
122 00027A09 0d efffffff39 50 movl _index,r0
123 00027A10 48 03 50 50 shll $3,r0,r0
124 00027A14 0d e000000000 efffffff29 movl _cvlf_1_data(r0),_sgl_value_1
125 00027A1F # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
126 00027A1F 0d efffffff23 50 movl _index,r0
127 00027A26 48 03 50 50 shll $3,r0,r0
128 00027A2A 0d e000000004 efffffff13 movl _cvlf_1_data+4(r0),_sgl_expected
129 00027A35 # sgl_value_2 = 0x40800000; /* floating '1' */
130 00027A35 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
131 00027A40 # /*
132 00027A40 # * If LOOP ON ERROR is set, this is the loop for this subtest.
133 00027A40 # * The force loop flag is set after the first error.
134 00027A40 # */
135 00027A40 # asm("_pipe3_1_lp1:");
136 00027A40 _pipe3_1_lp1:
137 00027A40 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
138 00027A40 0d efffffff02 54 movl _sgl_value_1,r4
139 00027A47 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
140 00027A47 0d effffffefb 55 movl _sgl_value_2,r5
141 00027A4E # asm("cvlf r4"); /* load (negate) the data */
142 00027A4E 76 54 cvlf r4
143 00027A50 # asm("stf r7"); /* store the result */
144 00027A50 26 57 stf r7
145 00027A52 # asm("mulf r5"); /* multipy by '1' (twice) */
146 00027A52 e6 55 mulf r5
147 00027A54 # asm("stf r8"); /* store the result */
148 00027A54 26 58 stf r8
149 00027A56 # if( force_loop )
150 00027A56 5d effffffeec tstl _force_loop
151 00027A5C 31 02 jeql L239
152 00027A5E # asm("brb _pipe3_1_lp1");; /* loop on the error */
153 00027A5E 11 e0 brb _pipe3_1_lp1
154 00027A60 L239:
155 00027A60 # /*
156 00027A60 # * verify the results
157 00027A60 # */
158 00027A60 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
159 00027A60 0d 57 effffffee1 movl r7,_sgl_st_acc
160 00027A67 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
161 00027A67 0d 58 effffffeda movl r8,_sgl_value_6
162 00027A6E # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
163 00027A6E # (sgl_value_6 != sgl_expected) )
164 00027A6E 1d effffffed4 effffffecf cmpl _sgl_st_acc,_sgl_expected
165 00027A79 21 0d jneq L9999
166 00027A7B 1d effffffec7 effffffec2 cmpl _sgl_value_6,_sgl_expected
167 00027A86 31 42 jeql L240
168 00027A88 L9999:
169 00027A88 # {
170 00027A88 # errcnt++; /* bump the error count */
171 00027A88 6d effffffeba incl _errcnt
172 00027A8E # if ( prt_error )
173 00027A8E 5d effffffeb4 tstl _prt_error
174 00027A94 31 0d jeql L241
175 00027A96 # print_pipe3_er("Reg. Data, no NOPS");
176 00027A96 .data 1
177 00000cf1 * L243:
178 00000cf1 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPS\0"
F204E4F505300
179 00000d04 * .text
180 00027A96 dd 8f00000cf1 pushl $L243
181 00027A9C fe 08 ef00000a13 callf $8,_print_pipe3_er
182 00027AA3 # if ( halt_flg )
183 00027AA3 L241:
184 00027AA3 5d effffffe9f tstl _halt_flg
185 00027AA9 31 0d jeql L244
186 00027AAB # pipe3_er_hlt( subtest );
187 00027AAB dd effffffe97 pushl _subtest
188 00027AB1 fe 08 ef00000b0a callf $8,_pipe3_er_hlt
189 00027AB8 # if ( loop_on_err ) {
190 00027AB8 L244:
191 00027AB8 5d effffffe8a tstl _loop_on_err
192 00027ABE 31 0a jeql L246
193 00027AC0 # force_loop = TRUE; /* set the force loop flag */
194 00027AC0 0d 01 effffffe81 movl $1,_force_loop
195 00027AC7 # asm("brw _pipe3_1_lp1"); /* and loop */
196 00027AC7 13 ff76 brw _pipe3_1_lp1
197 00027ACA # }
198 00027ACA # } /* end of compare error */
199 00027ACA L246:
200 00027ACA # } while( index++ < max_cvlf_1_index );
201 00027ACA L240:
202 00027ACA L237:
203 00027ACA 0d effffffe78 50 movl _index,r0
204 00027AD1 6d effffffe71 incl _index
205 00027AD7 1d 50 effffffe6a cmpl r0,_max_cvlf_1_index
206 00027ADE 81 03 13 ff26 jlss L238
207 00027AE3 L236:
208 00027AE3 # } /* end of subtest 1 */
209 00027AE3 40 ret#2
210 00027AE4 .set L232,0x0
211 00027AE4 L234:
212 00027AE4 13 ff16 jbr L235
213 00027AE7 .data
214 00000ce8 * .text
215 00027AE7 00 .align 1
216 00027AE8 .globl _pipe3_2
217 00027AE8 _pipe3_2:
218 00027AE8 0000 .word L247
219 00027AEA #
220 00027AEA #
221 00027AEA #
222 00027AEA #
223 00027AEA #
224 00027AEA #
225 00027AEA # /************************************************************************
226 00027AEA # *
227 00027AEA # * SUBTEST 2
228 00027AEA # * data in registers, 1 NO-OP
229 00027AEA # *
230 00027AEA # ************************************************************************/
231 00027AEA # pipe3_2()
232 00027AEA # {
233 00027AEA 13 00ea jbr L249
234 00027AED L250:
235 00027AED # force_loop = FALSE; /* clear force_loop flag */
236 00027AED 4d effffffe55 clrl _force_loop
237 00027AF3 # index = 0;
238 00027AF3 4d effffffe4f clrl _index
239 00027AF9 # do
240 00027AF9 L253:
241 00027AF9 # {
242 00027AF9 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
243 00027AF9 0d effffffe49 50 movl _index,r0
244 00027B00 48 03 50 50 shll $3,r0,r0
245 00027B04 0d e000000000 effffffe39 movl _cvlf_1_data(r0),_sgl_value_1
246 00027B0F # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
247 00027B0F 0d effffffe33 50 movl _index,r0
248 00027B16 48 03 50 50 shll $3,r0,r0
249 00027B1A 0d e000000004 effffffe23 movl _cvlf_1_data+4(r0),_sgl_expected
250 00027B25 # sgl_value_2 = 0x40800000; /* floating '1' */
251 00027B25 0d 8f40800000 effffffe18 movl $1082130432,_sgl_value_2
252 00027B30 # /*
253 00027B30 # * If LOOP ON ERROR is set, this is the loop for this subtest.
254 00027B30 # * The force loop flag is set after the first error.
255 00027B30 # */
256 00027B30 # asm("_pipe3_2_lp1:");
257 00027B30 _pipe3_2_lp1:
258 00027B30 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
259 00027B30 0d effffffe12 54 movl _sgl_value_1,r4
260 00027B37 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
261 00027B37 0d effffffe0b 55 movl _sgl_value_2,r5
262 00027B3E # asm("cvlf r4"); /* load (negate) the data */
263 00027B3E 76 54 cvlf r4
264 00027B40 # asm("nop");
265 00027B40 10 nop
266 00027B41 # asm("stf r7"); /* store the result */
267 00027B41 26 57 stf r7
268 00027B43 # asm("nop");
269 00027B43 10 nop
270 00027B44 # asm("mulf r5"); /* multipy by '1' (twice) */
271 00027B44 e6 55 mulf r5
272 00027B46 # asm("nop");
273 00027B46 10 nop
274 00027B47 # asm("stf r8"); /* store the result */
275 00027B47 26 58 stf r8
276 00027B49 # if( force_loop )
277 00027B49 5d effffffdf9 tstl _force_loop
278 00027B4F 31 02 jeql L254
279 00027B51 # asm("brb _pipe3_2_lp1");; /* loop on the error */
280 00027B51 11 dd brb _pipe3_2_lp1
281 00027B53 L254:
282 00027B53 # /*
283 00027B53 # * verify the results
284 00027B53 # */
285 00027B53 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
286 00027B53 0d 57 effffffdee movl r7,_sgl_st_acc
287 00027B5A # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
288 00027B5A 0d 58 effffffde7 movl r8,_sgl_value_6
289 00027B61 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
290 00027B61 # (sgl_value_6 != sgl_expected) )
291 00027B61 1d effffffde1 effffffddc cmpl _sgl_st_acc,_sgl_expected
292 00027B6C 21 0d jneq L9998
293 00027B6E 1d effffffdd4 effffffdcf cmpl _sgl_value_6,_sgl_expected
294 00027B79 31 42 jeql L255
295 00027B7B L9998:
296 00027B7B # {
297 00027B7B # errcnt++; /* bump the error count */
298 00027B7B 6d effffffdc7 incl _errcnt
299 00027B81 # if ( prt_error )
300 00027B81 5d effffffdc1 tstl _prt_error
301 00027B87 31 0d jeql L256
302 00027B89 # print_pipe3_er("Reg. Data, 1 NO-OP");
303 00027B89 .data 1
304 00000d04 * L257:
305 00000d04 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
306 00000d17 * .text
307 00027B89 dd 8f00000d04 pushl $L257
308 00027B8F fe 08 ef00000920 callf $8,_print_pipe3_er
309 00027B96 # if ( halt_flg )
310 00027B96 L256:
311 00027B96 5d effffffdac tstl _halt_flg
312 00027B9C 31 0d jeql L258
313 00027B9E # pipe3_er_hlt( subtest );
314 00027B9E dd effffffda4 pushl _subtest
315 00027BA4 fe 08 ef00000a17 callf $8,_pipe3_er_hlt
316 00027BAB # if ( loop_on_err ) {
317 00027BAB L258:
318 00027BAB 5d effffffd97 tstl _loop_on_err
319 00027BB1 31 0a jeql L259
320 00027BB3 # force_loop = TRUE; /* set the force loop flag */
321 00027BB3 0d 01 effffffd8e movl $1,_force_loop
322 00027BBA # asm("brw _pipe3_2_lp1"); /* and loop */
323 00027BBA 13 ff73 brw _pipe3_2_lp1
324 00027BBD # }
325 00027BBD # } /* end of compare error */
326 00027BBD L259:
327 00027BBD # } while( index++ < max_cvlf_1_index );
328 00027BBD L255:
329 00027BBD L252:
330 00027BBD 0d effffffd85 50 movl _index,r0
331 00027BC4 6d effffffd7e incl _index
332 00027BCA 1d 50 effffffd77 cmpl r0,_max_cvlf_1_index
333 00027BD1 81 03 13 ff23 jlss L253
334 00027BD6 L251:
335 00027BD6 # } /* end of subtest 2 */
336 00027BD6 40 ret#2
337 00027BD7 .set L247,0x0
338 00027BD7 L249:
339 00027BD7 13 ff13 jbr L250
340 00027BDA .data
341 00000ce8 * .text
342 00027BDA .align 1
343 00027BDA .globl _pipe3_3
344 00027BDA _pipe3_3:
345 00027BDA 0000 .word L260
346 00027BDC #
347 00027BDC #
348 00027BDC #
349 00027BDC #
350 00027BDC #
351 00027BDC #
352 00027BDC # /************************************************************************
353 00027BDC # *
354 00027BDC # * SUBTEST 3
355 00027BDC # * data in registers, 2 NO-OPs
356 00027BDC # *
357 00027BDC # ************************************************************************/
358 00027BDC # pipe3_3()
359 00027BDC # {
360 00027BDC 13 00ed jbr L262
361 00027BDF L263:
362 00027BDF # force_loop = FALSE; /* clear force_loop flag */
363 00027BDF 4d effffffd63 clrl _force_loop
364 00027BE5 # index = 0;
365 00027BE5 4d effffffd5d clrl _index
366 00027BEB # do
367 00027BEB L266:
368 00027BEB # {
369 00027BEB # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
370 00027BEB 0d effffffd57 50 movl _index,r0
371 00027BF2 48 03 50 50 shll $3,r0,r0
372 00027BF6 0d e000000000 effffffd47 movl _cvlf_1_data(r0),_sgl_value_1
373 00027C01 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
374 00027C01 0d effffffd41 50 movl _index,r0
375 00027C08 48 03 50 50 shll $3,r0,r0
376 00027C0C 0d e000000004 effffffd31 movl _cvlf_1_data+4(r0),_sgl_expected
377 00027C17 # sgl_value_2 = 0x40800000; /* floating '1' */
378 00027C17 0d 8f40800000 effffffd26 movl $1082130432,_sgl_value_2
379 00027C22 # /*
380 00027C22 # * If LOOP ON ERROR is set, this is the loop for this subtest.
381 00027C22 # * The force loop flag is set after the first error.
382 00027C22 # */
383 00027C22 # asm("_pipe3_3_lp1:");
384 00027C22 _pipe3_3_lp1:
385 00027C22 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
386 00027C22 0d effffffd20 54 movl _sgl_value_1,r4
387 00027C29 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
388 00027C29 0d effffffd19 55 movl _sgl_value_2,r5
389 00027C30 # asm("cvlf r4"); /* load (negate) the data */
390 00027C30 76 54 cvlf r4
391 00027C32 # asm("nop");
392 00027C32 10 nop
393 00027C33 # asm("nop");
394 00027C33 10 nop
395 00027C34 # asm("stf r7"); /* store the result */
396 00027C34 26 57 stf r7
397 00027C36 # asm("nop");
398 00027C36 10 nop
399 00027C37 # asm("nop");
400 00027C37 10 nop
401 00027C38 # asm("mulf r5"); /* multipy by '1' (twice) */
402 00027C38 e6 55 mulf r5
403 00027C3A # asm("nop");
404 00027C3A 10 nop
405 00027C3B # asm("nop");
406 00027C3B 10 nop
407 00027C3C # asm("stf r8"); /* store the result */
408 00027C3C 26 58 stf r8
409 00027C3E # if( force_loop )
410 00027C3E 5d effffffd04 tstl _force_loop
411 00027C44 31 02 jeql L267
412 00027C46 # asm("brb _pipe3_3_lp1");; /* loop on the error */
413 00027C46 11 da brb _pipe3_3_lp1
414 00027C48 L267:
415 00027C48 # /*
416 00027C48 # * verify the results
417 00027C48 # */
418 00027C48 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
419 00027C48 0d 57 effffffcf9 movl r7,_sgl_st_acc
420 00027C4F # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
421 00027C4F 0d 58 effffffcf2 movl r8,_sgl_value_6
422 00027C56 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
423 00027C56 # (sgl_value_6 != sgl_expected) )
424 00027C56 1d effffffcec effffffce7 cmpl _sgl_st_acc,_sgl_expected
425 00027C61 21 0d jneq L9997
426 00027C63 1d effffffcdf effffffcda cmpl _sgl_value_6,_sgl_expected
427 00027C6E 31 42 jeql L268
428 00027C70 L9997:
429 00027C70 # {
430 00027C70 # errcnt++; /* bump the error count */
431 00027C70 6d effffffcd2 incl _errcnt
432 00027C76 # if ( prt_error )
433 00027C76 5d effffffccc tstl _prt_error
434 00027C7C 31 0d jeql L269
435 00027C7E # print_pipe3_er("Reg. Data, 2 NO-OPS");
436 00027C7E .data 1
437 00000d17 * L270:
438 00000d17 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPS\0"
04E4F2D4F505300
439 00000d2b * .text
440 00027C7E dd 8f00000d17 pushl $L270
441 00027C84 fe 08 ef0000082b callf $8,_print_pipe3_er
442 00027C8B # if ( halt_flg )
443 00027C8B L269:
444 00027C8B 5d effffffcb7 tstl _halt_flg
445 00027C91 31 0d jeql L271
446 00027C93 # pipe3_er_hlt( subtest );
447 00027C93 dd effffffcaf pushl _subtest
448 00027C99 fe 08 ef00000922 callf $8,_pipe3_er_hlt
449 00027CA0 # if ( loop_on_err ) {
450 00027CA0 L271:
451 00027CA0 5d effffffca2 tstl _loop_on_err
452 00027CA6 31 0a jeql L272
453 00027CA8 # force_loop = TRUE; /* set the force loop flag */
454 00027CA8 0d 01 effffffc99 movl $1,_force_loop
455 00027CAF # asm("brw _pipe3_3_lp1"); /* and loop */
456 00027CAF 13 ff70 brw _pipe3_3_lp1
457 00027CB2 # }
458 00027CB2 # } /* end of compare error */
459 00027CB2 L272:
460 00027CB2 # } while( index++ < max_cvlf_1_index );
461 00027CB2 L268:
462 00027CB2 L265:
463 00027CB2 0d effffffc90 50 movl _index,r0
464 00027CB9 6d effffffc89 incl _index
465 00027CBF 1d 50 effffffc82 cmpl r0,_max_cvlf_1_index
466 00027CC6 81 03 13 ff20 jlss L266
467 00027CCB L264:
468 00027CCB # } /* end of subtest 3 */
469 00027CCB 40 ret#2
470 00027CCC .set L260,0x0
471 00027CCC L262:
472 00027CCC 13 ff10 jbr L263
473 00027CCF .data
474 00000ce8 * .text
475 00027CCF 00 .align 1
476 00027CD0 .globl _pipe3_4
477 00027CD0 _pipe3_4:
478 00027CD0 0000 .word L273
479 00027CD2 #
480 00027CD2 #
481 00027CD2 #
482 00027CD2 #
483 00027CD2 #
484 00027CD2 #
485 00027CD2 # /************************************************************************
486 00027CD2 # *
487 00027CD2 # * SUBTEST 4
488 00027CD2 # * data in registers, 3 NO-OPs
489 00027CD2 # *
490 00027CD2 # ************************************************************************/
491 00027CD2 # pipe3_4()
492 00027CD2 # {
493 00027CD2 13 00f0 jbr L275
494 00027CD5 L276:
495 00027CD5 # force_loop = FALSE; /* clear force_loop flag */
496 00027CD5 4d effffffc6d clrl _force_loop
497 00027CDB # index = 0;
498 00027CDB 4d effffffc67 clrl _index
499 00027CE1 # do
500 00027CE1 L279:
501 00027CE1 # {
502 00027CE1 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
503 00027CE1 0d effffffc61 50 movl _index,r0
504 00027CE8 48 03 50 50 shll $3,r0,r0
505 00027CEC 0d e000000000 effffffc51 movl _cvlf_1_data(r0),_sgl_value_1
506 00027CF7 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
507 00027CF7 0d effffffc4b 50 movl _index,r0
508 00027CFE 48 03 50 50 shll $3,r0,r0
509 00027D02 0d e000000004 effffffc3b movl _cvlf_1_data+4(r0),_sgl_expected
510 00027D0D # sgl_value_2 = 0x40800000; /* floating '1' */
511 00027D0D 0d 8f40800000 effffffc30 movl $1082130432,_sgl_value_2
512 00027D18 # /*
513 00027D18 # * If LOOP ON ERROR is set, this is the loop for this subtest.
514 00027D18 # * The force loop flag is set after the first error.
515 00027D18 # */
516 00027D18 # asm("_pipe3_4_lp1:");
517 00027D18 _pipe3_4_lp1:
518 00027D18 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
519 00027D18 0d effffffc2a 54 movl _sgl_value_1,r4
520 00027D1F # asm("movl _sgl_value_2,r5"); /* move data to r5 */
521 00027D1F 0d effffffc23 55 movl _sgl_value_2,r5
522 00027D26 # asm("cvlf r4"); /* load (negate) the data */
523 00027D26 76 54 cvlf r4
524 00027D28 # asm("nop");
525 00027D28 10 nop
526 00027D29 # asm("nop");
527 00027D29 10 nop
528 00027D2A # asm("nop");
529 00027D2A 10 nop
530 00027D2B # asm("stf r7"); /* store the result */
531 00027D2B 26 57 stf r7
532 00027D2D # asm("nop");
533 00027D2D 10 nop
534 00027D2E # asm("nop");
535 00027D2E 10 nop
536 00027D2F # asm("nop");
537 00027D2F 10 nop
538 00027D30 # asm("mulf r5"); /* multipy by '1' (twice) */
539 00027D30 e6 55 mulf r5
540 00027D32 # asm("nop");
541 00027D32 10 nop
542 00027D33 # asm("nop");
543 00027D33 10 nop
544 00027D34 # asm("nop");
545 00027D34 10 nop
546 00027D35 # asm("stf r8"); /* store the result */
547 00027D35 26 58 stf r8
548 00027D37 # if( force_loop )
549 00027D37 5d effffffc0b tstl _force_loop
550 00027D3D 31 02 jeql L280
551 00027D3F # asm("brb _pipe3_4_lp1");; /* loop on the error */
552 00027D3F 11 d7 brb _pipe3_4_lp1
553 00027D41 L280:
554 00027D41 # /*
555 00027D41 # * verify the results
556 00027D41 # */
557 00027D41 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
558 00027D41 0d 57 effffffc00 movl r7,_sgl_st_acc
559 00027D48 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
560 00027D48 0d 58 effffffbf9 movl r8,_sgl_value_6
561 00027D4F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
562 00027D4F # (sgl_value_6 != sgl_expected) )
563 00027D4F 1d effffffbf3 effffffbee cmpl _sgl_st_acc,_sgl_expected
564 00027D5A 21 0d jneq L9996
565 00027D5C 1d effffffbe6 effffffbe1 cmpl _sgl_value_6,_sgl_expected
566 00027D67 31 42 jeql L281
567 00027D69 L9996:
568 00027D69 # {
569 00027D69 # errcnt++; /* bump the error count */
570 00027D69 6d effffffbd9 incl _errcnt
571 00027D6F # if ( prt_error )
572 00027D6F 5d effffffbd3 tstl _prt_error
573 00027D75 31 0d jeql L282
574 00027D77 # print_pipe3_er("Reg. Data, 3 NO-OPS");
575 00027D77 .data 1
576 00000d2b * L283:
577 00000d2b * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPS\0"
04E4F2D4F505300
578 00000d3f * .text
579 00027D77 dd 8f00000d2b pushl $L283
580 00027D7D fe 08 ef00000732 callf $8,_print_pipe3_er
581 00027D84 # if ( halt_flg )
582 00027D84 L282:
583 00027D84 5d effffffbbe tstl _halt_flg
584 00027D8A 31 0d jeql L284
585 00027D8C # pipe3_er_hlt( subtest );
586 00027D8C dd effffffbb6 pushl _subtest
587 00027D92 fe 08 ef00000829 callf $8,_pipe3_er_hlt
588 00027D99 # if ( loop_on_err ) {
589 00027D99 L284:
590 00027D99 5d effffffba9 tstl _loop_on_err
591 00027D9F 31 0a jeql L285
592 00027DA1 # force_loop = TRUE; /* set the force loop flag */
593 00027DA1 0d 01 effffffba0 movl $1,_force_loop
594 00027DA8 # asm("brw _pipe3_4_lp1"); /* and loop */
595 00027DA8 13 ff6d brw _pipe3_4_lp1
596 00027DAB # }
597 00027DAB # } /* end of compare error */
598 00027DAB L285:
599 00027DAB # } while( index++ < max_cvlf_1_index );
600 00027DAB L281:
601 00027DAB L278:
602 00027DAB 0d effffffb97 50 movl _index,r0
603 00027DB2 6d effffffb90 incl _index
604 00027DB8 1d 50 effffffb89 cmpl r0,_max_cvlf_1_index
605 00027DBF 81 03 13 ff1d jlss L279
606 00027DC4 L277:
607 00027DC4 # } /* end of subtest 4 */
608 00027DC4 40 ret#2
609 00027DC5 .set L273,0x0
610 00027DC5 L275:
611 00027DC5 13 ff0d jbr L276
612 00027DC8 .data
613 00000ce8 * .text
614 00027DC8 .align 1
615 00027DC8 .globl _pipe3_5
616 00027DC8 _pipe3_5:
617 00027DC8 0000 .word L286
618 00027DCA #
619 00027DCA #
620 00027DCA #
621 00027DCA #
622 00027DCA #
623 00027DCA #
624 00027DCA #
625 00027DCA # /************************************************************************
626 00027DCA # *
627 00027DCA # * SUBTEST 5
628 00027DCA # * data in Cache, no NO-OPs
629 00027DCA # *
630 00027DCA # ************************************************************************/
631 00027DCA # pipe3_5()
632 00027DCA # {
633 00027DCA 13 00db jbr L288
634 00027DCD L289:
635 00027DCD # force_loop = FALSE; /* clear force_loop flag */
636 00027DCD 4d effffffb75 clrl _force_loop
637 00027DD3 # index = 0;
638 00027DD3 4d effffffb6f clrl _index
639 00027DD9 # do
640 00027DD9 L292:
641 00027DD9 # {
642 00027DD9 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
643 00027DD9 0d effffffb69 50 movl _index,r0
644 00027DE0 48 03 50 50 shll $3,r0,r0
645 00027DE4 0d e000000000 effffffb59 movl _cvlf_1_data(r0),_sgl_value_1
646 00027DEF # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
647 00027DEF 0d effffffb53 50 movl _index,r0
648 00027DF6 48 03 50 50 shll $3,r0,r0
649 00027DFA 0d e000000004 effffffb43 movl _cvlf_1_data+4(r0),_sgl_expected
650 00027E05 # sgl_value_2 = 0x40800000; /* floating '1' */
651 00027E05 0d 8f40800000 effffffb38 movl $1082130432,_sgl_value_2
652 00027E10 # /*
653 00027E10 # * If LOOP ON ERROR is set, this is the loop for this subtest.
654 00027E10 # * The force loop flag is set after the first error.
655 00027E10 # */
656 00027E10 # asm("_pipe3_5_lp1:");
657 00027E10 _pipe3_5_lp1:
658 00027E10 # asm("cvlf _sgl_value_1"); /* load (negate) the data */
659 00027E10 76 effffffb32 cvlf _sgl_value_1
660 00027E16 # asm("stf _sgl_st_acc"); /* store the result */
661 00027E16 26 effffffb2c stf _sgl_st_acc
662 00027E1C # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
663 00027E1C e6 effffffb26 mulf _sgl_value_2
664 00027E22 # asm("stf _sgl_value_6"); /* store the result */
665 00027E22 26 effffffb20 stf _sgl_value_6
666 00027E28 # if( force_loop )
667 00027E28 5d effffffb1a tstl _force_loop
668 00027E2E 31 02 jeql L293
669 00027E30 # asm("brb _pipe3_5_lp1");; /* loop on the error */
670 00027E30 11 de brb _pipe3_5_lp1
671 00027E32 L293:
672 00027E32 # /*
673 00027E32 # * verify the results
674 00027E32 # */
675 00027E32 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
676 00027E32 # (sgl_value_6 != sgl_expected) )
677 00027E32 1d effffffb10 effffffb0b cmpl _sgl_st_acc,_sgl_expected
678 00027E3D 21 0d jneq L9995
679 00027E3F 1d effffffb03 effffffafe cmpl _sgl_value_6,_sgl_expected
680 00027E4A 31 42 jeql L294
681 00027E4C L9995:
682 00027E4C # {
683 00027E4C # errcnt++; /* bump the error count */
684 00027E4C 6d effffffaf6 incl _errcnt
685 00027E52 # if ( prt_error )
686 00027E52 5d effffffaf0 tstl _prt_error
687 00027E58 31 0d jeql L295
688 00027E5A # print_pipe3_er("Cache Data, no NO-OPS");
689 00027E5A .data 1
690 00000d3f * L296:
691 00000d3f * 436163686520446174612C206 .ascii "Cache Data, no NO-OPS\0"
E6F204E4F2D4F505300
692 00000d55 * .text
693 00027E5A dd 8f00000d3f pushl $L296
694 00027E60 fe 08 ef0000064f callf $8,_print_pipe3_er
695 00027E67 # if ( halt_flg )
696 00027E67 L295:
697 00027E67 5d effffffadb tstl _halt_flg
698 00027E6D 31 0d jeql L297
699 00027E6F # pipe3_er_hlt( subtest );
700 00027E6F dd effffffad3 pushl _subtest
701 00027E75 fe 08 ef00000746 callf $8,_pipe3_er_hlt
702 00027E7C # if ( loop_on_err ) {
703 00027E7C L297:
704 00027E7C 5d effffffac6 tstl _loop_on_err
705 00027E82 31 0a jeql L298
706 00027E84 # force_loop = TRUE; /* set the force loop flag */
707 00027E84 0d 01 effffffabd movl $1,_force_loop
708 00027E8B # asm("brw _pipe3_5_lp1"); /* and loop */
709 00027E8B 13 ff82 brw _pipe3_5_lp1
710 00027E8E # }
711 00027E8E # } /* end of compare error */
712 00027E8E L298:
713 00027E8E # } while( index++ < max_cvlf_1_index );
714 00027E8E L294:
715 00027E8E L291:
716 00027E8E 0d effffffab4 50 movl _index,r0
717 00027E95 6d effffffaad incl _index
718 00027E9B 1d 50 effffffaa6 cmpl r0,_max_cvlf_1_index
719 00027EA2 81 03 13 ff32 jlss L292
720 00027EA7 L290:
721 00027EA7 # } /* end of subtest 5 */
722 00027EA7 40 ret#2
723 00027EA8 .set L286,0x0
724 00027EA8 L288:
725 00027EA8 13 ff22 jbr L289
726 00027EAB .data
727 00000ce8 * .text
728 00027EAB 00 .align 1
729 00027EAC .globl _pipe3_6
730 00027EAC _pipe3_6:
731 00027EAC 0000 .word L299
732 00027EAE #
733 00027EAE #
734 00027EAE #
735 00027EAE #
736 00027EAE #
737 00027EAE #
738 00027EAE # /************************************************************************
739 00027EAE # *
740 00027EAE # * SUBTEST 6
741 00027EAE # * data in Cache, 1 NO-OP
742 00027EAE # *
743 00027EAE # ************************************************************************/
744 00027EAE # pipe3_6()
745 00027EAE # {
746 00027EAE 13 00de jbr L301
747 00027EB1 L302:
748 00027EB1 # force_loop = FALSE; /* clear force_loop flag */
749 00027EB1 4d effffffa91 clrl _force_loop
750 00027EB7 # index = 0;
751 00027EB7 4d effffffa8b clrl _index
752 00027EBD # do
753 00027EBD L305:
754 00027EBD # {
755 00027EBD # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
756 00027EBD 0d effffffa85 50 movl _index,r0
757 00027EC4 48 03 50 50 shll $3,r0,r0
758 00027EC8 0d e000000000 effffffa75 movl _cvlf_1_data(r0),_sgl_value_1
759 00027ED3 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
760 00027ED3 0d effffffa6f 50 movl _index,r0
761 00027EDA 48 03 50 50 shll $3,r0,r0
762 00027EDE 0d e000000004 effffffa5f movl _cvlf_1_data+4(r0),_sgl_expected
763 00027EE9 # sgl_value_2 = 0x40800000; /* floating '1' */
764 00027EE9 0d 8f40800000 effffffa54 movl $1082130432,_sgl_value_2
765 00027EF4 # /*
766 00027EF4 # * If LOOP ON ERROR is set, this is the loop for this subtest.
767 00027EF4 # * The force loop flag is set after the first error.
768 00027EF4 # */
769 00027EF4 # asm("_pipe3_6_lp1:");
770 00027EF4 _pipe3_6_lp1:
771 00027EF4 # asm("cvlf _sgl_value_1"); /* load (negate) the data */
772 00027EF4 76 effffffa4e cvlf _sgl_value_1
773 00027EFA # asm("nop");
774 00027EFA 10 nop
775 00027EFB # asm("stf _sgl_st_acc"); /* store the result */
776 00027EFB 26 effffffa47 stf _sgl_st_acc
777 00027F01 # asm("nop");
778 00027F01 10 nop
779 00027F02 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
780 00027F02 e6 effffffa40 mulf _sgl_value_2
781 00027F08 # asm("nop");
782 00027F08 10 nop
783 00027F09 # asm("stf _sgl_value_6"); /* store the result */
784 00027F09 26 effffffa39 stf _sgl_value_6
785 00027F0F # if( force_loop )
786 00027F0F 5d effffffa33 tstl _force_loop
787 00027F15 31 02 jeql L306
788 00027F17 # asm("brb _pipe3_6_lp1");; /* loop on the error */
789 00027F17 11 db brb _pipe3_6_lp1
790 00027F19 L306:
791 00027F19 # /*
792 00027F19 # * verify the results
793 00027F19 # */
794 00027F19 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
795 00027F19 # (sgl_value_6 != sgl_expected) )
796 00027F19 1d effffffa29 effffffa24 cmpl _sgl_st_acc,_sgl_expected
797 00027F24 21 0d jneq L9994
798 00027F26 1d effffffa1c effffffa17 cmpl _sgl_value_6,_sgl_expected
799 00027F31 31 42 jeql L307
800 00027F33 L9994:
801 00027F33 # {
802 00027F33 # errcnt++; /* bump the error count */
803 00027F33 6d effffffa0f incl _errcnt
804 00027F39 # if ( prt_error )
805 00027F39 5d effffffa09 tstl _prt_error
806 00027F3F 31 0d jeql L308
807 00027F41 # print_pipe3_er("Cache Data, 1 NO-OP");
808 00027F41 .data 1
809 00000d55 * L309:
810 00000d55 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
811 00000d69 * .text
812 00027F41 dd 8f00000d55 pushl $L309
813 00027F47 fe 08 ef00000568 callf $8,_print_pipe3_er
814 00027F4E # if ( halt_flg )
815 00027F4E L308:
816 00027F4E 5d effffff9f4 tstl _halt_flg
817 00027F54 31 0d jeql L310
818 00027F56 # pipe3_er_hlt( subtest );
819 00027F56 dd effffff9ec pushl _subtest
820 00027F5C fe 08 ef0000065f callf $8,_pipe3_er_hlt
821 00027F63 # if ( loop_on_err ) {
822 00027F63 L310:
823 00027F63 5d effffff9df tstl _loop_on_err
824 00027F69 31 0a jeql L311
825 00027F6B # force_loop = TRUE; /* set the force loop flag */
826 00027F6B 0d 01 effffff9d6 movl $1,_force_loop
827 00027F72 # asm("brw _pipe3_6_lp1"); /* and loop */
828 00027F72 13 ff7f brw _pipe3_6_lp1
829 00027F75 # }
830 00027F75 # } /* end of compare error */
831 00027F75 L311:
832 00027F75 # } while( index++ < max_cvlf_1_index );
833 00027F75 L307:
834 00027F75 L304:
835 00027F75 0d effffff9cd 50 movl _index,r0
836 00027F7C 6d effffff9c6 incl _index
837 00027F82 1d 50 effffff9bf cmpl r0,_max_cvlf_1_index
838 00027F89 81 03 13 ff2f jlss L305
839 00027F8E L303:
840 00027F8E # } /* end of subtest 6 */
841 00027F8E 40 ret#2
842 00027F8F .set L299,0x0
843 00027F8F L301:
844 00027F8F 13 ff1f jbr L302
845 00027F92 .data
846 00000ce8 * .text
847 00027F92 .align 1
848 00027F92 .globl _pipe3_7
849 00027F92 _pipe3_7:
850 00027F92 0000 .word L312
851 00027F94 #
852 00027F94 #
853 00027F94 #
854 00027F94 #
855 00027F94 #
856 00027F94 #
857 00027F94 # /************************************************************************
858 00027F94 # *
859 00027F94 # * SUBTEST 7
860 00027F94 # * data in Cache, 2 NO-OPs
861 00027F94 # *
862 00027F94 # ************************************************************************/
863 00027F94 # pipe3_7()
864 00027F94 # {
865 00027F94 13 00e1 jbr L314
866 00027F97 L315:
867 00027F97 # force_loop = FALSE; /* clear force_loop flag */
868 00027F97 4d effffff9ab clrl _force_loop
869 00027F9D # index = 0;
870 00027F9D 4d effffff9a5 clrl _index
871 00027FA3 # do
872 00027FA3 L318:
873 00027FA3 # {
874 00027FA3 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
875 00027FA3 0d effffff99f 50 movl _index,r0
876 00027FAA 48 03 50 50 shll $3,r0,r0
877 00027FAE 0d e000000000 effffff98f movl _cvlf_1_data(r0),_sgl_value_1
878 00027FB9 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
879 00027FB9 0d effffff989 50 movl _index,r0
880 00027FC0 48 03 50 50 shll $3,r0,r0
881 00027FC4 0d e000000004 effffff979 movl _cvlf_1_data+4(r0),_sgl_expected
882 00027FCF # sgl_value_2 = 0x40800000; /* floating '1' */
883 00027FCF 0d 8f40800000 effffff96e movl $1082130432,_sgl_value_2
884 00027FDA # /*
885 00027FDA # * If LOOP ON ERROR is set, this is the loop for this subtest.
886 00027FDA # * The force loop flag is set after the first error.
887 00027FDA # */
888 00027FDA # asm("_pipe3_7_lp1:");
889 00027FDA _pipe3_7_lp1:
890 00027FDA # asm("cvlf _sgl_value_1"); /* load (negate) the data */
891 00027FDA 76 effffff968 cvlf _sgl_value_1
892 00027FE0 # asm("nop");
893 00027FE0 10 nop
894 00027FE1 # asm("nop");
895 00027FE1 10 nop
896 00027FE2 # asm("stf _sgl_st_acc"); /* store the result */
897 00027FE2 26 effffff960 stf _sgl_st_acc
898 00027FE8 # asm("nop");
899 00027FE8 10 nop
900 00027FE9 # asm("nop");
901 00027FE9 10 nop
902 00027FEA # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
903 00027FEA e6 effffff958 mulf _sgl_value_2
904 00027FF0 # asm("nop");
905 00027FF0 10 nop
906 00027FF1 # asm("nop");
907 00027FF1 10 nop
908 00027FF2 # asm("stf _sgl_value_6"); /* store the result */
909 00027FF2 26 effffff950 stf _sgl_value_6
910 00027FF8 # if( force_loop )
911 00027FF8 5d effffff94a tstl _force_loop
912 00027FFE 31 02 jeql L319
913 00028000 # asm("brb _pipe3_7_lp1");; /* loop on the error */
914 00028000 11 d8 brb _pipe3_7_lp1
915 00028002 L319:
916 00028002 # /*
917 00028002 # * verify the results
918 00028002 # */
919 00028002 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
920 00028002 # (sgl_value_6 != sgl_expected) )
921 00028002 1d effffff940 effffff93b cmpl _sgl_st_acc,_sgl_expected
922 0002800D 21 0d jneq L9993
923 0002800F 1d effffff933 effffff92e cmpl _sgl_value_6,_sgl_expected
924 0002801A 31 42 jeql L320
925 0002801C L9993:
926 0002801C # {
927 0002801C # errcnt++; /* bump the error count */
928 0002801C 6d effffff926 incl _errcnt
929 00028022 # if ( prt_error )
930 00028022 5d effffff920 tstl _prt_error
931 00028028 31 0d jeql L321
932 0002802A # print_pipe3_er("Cache Data, 2 NO-OPS");
933 0002802A .data 1
934 00000d69 * L322:
935 00000d69 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPS\0"
2204E4F2D4F505300
936 00000d7e * .text
937 0002802A dd 8f00000d69 pushl $L322
938 00028030 fe 08 ef0000047f callf $8,_print_pipe3_er
939 00028037 # if ( halt_flg )
940 00028037 L321:
941 00028037 5d effffff90b tstl _halt_flg
942 0002803D 31 0d jeql L323
943 0002803F # pipe3_er_hlt( subtest );
944 0002803F dd effffff903 pushl _subtest
945 00028045 fe 08 ef00000576 callf $8,_pipe3_er_hlt
946 0002804C # if ( loop_on_err ) {
947 0002804C L323:
948 0002804C 5d effffff8f6 tstl _loop_on_err
949 00028052 31 0a jeql L324
950 00028054 # force_loop = TRUE; /* set the force loop flag */
951 00028054 0d 01 effffff8ed movl $1,_force_loop
952 0002805B # asm("brw _pipe3_7_lp1"); /* and loop */
953 0002805B 13 ff7c brw _pipe3_7_lp1
954 0002805E # }
955 0002805E # } /* end of compare error */
956 0002805E L324:
957 0002805E # } while( index++ < max_cvlf_1_index );
958 0002805E L320:
959 0002805E L317:
960 0002805E 0d effffff8e4 50 movl _index,r0
961 00028065 6d effffff8dd incl _index
962 0002806B 1d 50 effffff8d6 cmpl r0,_max_cvlf_1_index
963 00028072 81 03 13 ff2c jlss L318
964 00028077 L316:
965 00028077 # } /* end of subtest 7 */
966 00028077 40 ret#2
967 00028078 .set L312,0x0
968 00028078 L314:
969 00028078 13 ff1c jbr L315
970 0002807B .data
971 00000ce8 * .text
972 0002807B 00 .align 1
973 0002807C .globl _pipe3_8
974 0002807C _pipe3_8:
975 0002807C 0000 .word L325
976 0002807E #
977 0002807E #
978 0002807E #
979 0002807E #
980 0002807E #
981 0002807E #
982 0002807E # /************************************************************************
983 0002807E # *
984 0002807E # * SUBTEST 8
985 0002807E # * data in Cache, 3 NO-OPs
986 0002807E # *
987 0002807E # ************************************************************************/
988 0002807E # pipe3_8()
989 0002807E # {
990 0002807E 13 00e4 jbr L327
991 00028081 L328:
992 00028081 # force_loop = FALSE; /* clear force_loop flag */
993 00028081 4d effffff8c1 clrl _force_loop
994 00028087 # index = 0;
995 00028087 4d effffff8bb clrl _index
996 0002808D # do
997 0002808D L331:
998 0002808D # {
999 0002808D # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1000 0002808D 0d effffff8b5 50 movl _index,r0
1001 00028094 48 03 50 50 shll $3,r0,r0
1002 00028098 0d e000000000 effffff8a5 movl _cvlf_1_data(r0),_sgl_value_1
1003 000280A3 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1004 000280A3 0d effffff89f 50 movl _index,r0
1005 000280AA 48 03 50 50 shll $3,r0,r0
1006 000280AE 0d e000000004 effffff88f movl _cvlf_1_data+4(r0),_sgl_expected
1007 000280B9 # sgl_value_2 = 0x40800000; /* floating '1' */
1008 000280B9 0d 8f40800000 effffff884 movl $1082130432,_sgl_value_2
1009 000280C4 # /*
1010 000280C4 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1011 000280C4 # * The force loop flag is set after the first error.
1012 000280C4 # */
1013 000280C4 # asm("_pipe3_8_lp1:");
1014 000280C4 _pipe3_8_lp1:
1015 000280C4 # asm("cvlf _sgl_value_1"); /* load (negate) the data */
1016 000280C4 76 effffff87e cvlf _sgl_value_1
1017 000280CA # asm("nop");
1018 000280CA 10 nop
1019 000280CB # asm("nop");
1020 000280CB 10 nop
1021 000280CC # asm("nop");
1022 000280CC 10 nop
1023 000280CD # asm("stf _sgl_st_acc"); /* store the result */
1024 000280CD 26 effffff875 stf _sgl_st_acc
1025 000280D3 # asm("nop");
1026 000280D3 10 nop
1027 000280D4 # asm("nop");
1028 000280D4 10 nop
1029 000280D5 # asm("nop");
1030 000280D5 10 nop
1031 000280D6 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
1032 000280D6 e6 effffff86c mulf _sgl_value_2
1033 000280DC # asm("nop");
1034 000280DC 10 nop
1035 000280DD # asm("nop");
1036 000280DD 10 nop
1037 000280DE # asm("nop");
1038 000280DE 10 nop
1039 000280DF # asm("stf _sgl_value_6"); /* store the result */
1040 000280DF 26 effffff863 stf _sgl_value_6
1041 000280E5 # if( force_loop )
1042 000280E5 5d effffff85d tstl _force_loop
1043 000280EB 31 02 jeql L332
1044 000280ED # asm("brb _pipe3_8_lp1");; /* loop on the error */
1045 000280ED 11 d5 brb _pipe3_8_lp1
1046 000280EF L332:
1047 000280EF # /*
1048 000280EF # * verify the results
1049 000280EF # */
1050 000280EF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1051 000280EF # (sgl_value_6 != sgl_expected) )
1052 000280EF 1d effffff853 effffff84e cmpl _sgl_st_acc,_sgl_expected
1053 000280FA 21 0d jneq L9992
1054 000280FC 1d effffff846 effffff841 cmpl _sgl_value_6,_sgl_expected
1055 00028107 31 42 jeql L333
1056 00028109 L9992:
1057 00028109 # {
1058 00028109 # errcnt++; /* bump the error count */
1059 00028109 6d effffff839 incl _errcnt
1060 0002810F # if ( prt_error )
1061 0002810F 5d effffff833 tstl _prt_error
1062 00028115 31 0d jeql L334
1063 00028117 # print_pipe3_er("Cache Data, 3 NO-OPS");
1064 00028117 .data 1
1065 00000d7e * L335:
1066 00000d7e * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPS\0"
3204E4F2D4F505300
1067 00000d93 * .text
1068 00028117 dd 8f00000d7e pushl $L335
1069 0002811D fe 08 ef00000392 callf $8,_print_pipe3_er
1070 00028124 # if ( halt_flg )
1071 00028124 L334:
1072 00028124 5d effffff81e tstl _halt_flg
1073 0002812A 31 0d jeql L336
1074 0002812C # pipe3_er_hlt( subtest );
1075 0002812C dd effffff816 pushl _subtest
1076 00028132 fe 08 ef00000489 callf $8,_pipe3_er_hlt
1077 00028139 # if ( loop_on_err ) {
1078 00028139 L336:
1079 00028139 5d effffff809 tstl _loop_on_err
1080 0002813F 31 0a jeql L337
1081 00028141 # force_loop = TRUE; /* set the force loop flag */
1082 00028141 0d 01 effffff800 movl $1,_force_loop
1083 00028148 # asm("brw _pipe3_8_lp1"); /* and loop */
1084 00028148 13 ff79 brw _pipe3_8_lp1
1085 0002814B # }
1086 0002814B # } /* end of compare error */
1087 0002814B L337:
1088 0002814B # } while( index++ < max_cvlf_1_index );
1089 0002814B L333:
1090 0002814B L330:
1091 0002814B 0d effffff7f7 50 movl _index,r0
1092 00028152 6d effffff7f0 incl _index
1093 00028158 1d 50 effffff7e9 cmpl r0,_max_cvlf_1_index
1094 0002815F 81 03 13 ff29 jlss L331
1095 00028164 L329:
1096 00028164 # } /* end of subtest 8 */
1097 00028164 40 ret#2
1098 00028165 .set L325,0x0
1099 00028165 L327:
1100 00028165 13 ff19 jbr L328
1101 00028168 .data
1102 00000ce8 * .text
1103 00028168 .align 1
1104 00028168 .globl _pipe3_9
1105 00028168 _pipe3_9:
1106 00028168 0000 .word L338
1107 0002816A #
1108 0002816A #
1109 0002816A #
1110 0002816A #
1111 0002816A #
1112 0002816A #
1113 0002816A # /*****************************************************************************
1114 0002816A # *
1115 0002816A # * SUBTEST 9
1116 0002816A # * data on the stack, no NO-OPs
1117 0002816A # *
1118 0002816A # *****************************************************************************/
1119 0002816A # pipe3_9()
1120 0002816A # {
1121 0002816A 13 017b jbr L340
1122 0002816D L341:
1123 0002816D # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1124 0002816D ed 6d effffff7d4 moval (r13),_pre_event_fp
1125 00028174 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1126 00028174 ed 6e effffff7cd moval (r14),_pre_event_sp
1127 0002817B # force_loop = FALSE; /* clear force_loop flag */
1128 0002817B 4d effffff7c7 clrl _force_loop
1129 00028181 # index = 0;
1130 00028181 4d effffff7c1 clrl _index
1131 00028187 # do
1132 00028187 L344:
1133 00028187 # {
1134 00028187 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1135 00028187 0d effffff7bb 50 movl _index,r0
1136 0002818E 48 03 50 50 shll $3,r0,r0
1137 00028192 0d e000000000 effffff7ab movl _cvlf_1_data(r0),_sgl_value_1
1138 0002819D # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1139 0002819D 0d effffff7a5 50 movl _index,r0
1140 000281A4 48 03 50 50 shll $3,r0,r0
1141 000281A8 0d e000000004 effffff795 movl _cvlf_1_data+4(r0),_sgl_expected
1142 000281B3 # sgl_value_2 = 0x40800000; /* floating '1' */
1143 000281B3 0d 8f40800000 effffff78a movl $1082130432,_sgl_value_2
1144 000281BE # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1145 000281BE ed effffff784 effffff77f moval _pointer_data,_sgl_value_4
1146 000281C9 # /*
1147 000281C9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1148 000281C9 # * The force loop flag is set after the first error.
1149 000281C9 # */
1150 000281C9 # asm("_pipe3_9_lp1:");
1151 000281C9 _pipe3_9_lp1:
1152 000281C9 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1153 000281C9 ed effffff779 5e moval _pointer_data,r14
1154 000281D0 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '1' */
1155 000281D0 0d effffff772 7e movl _sgl_value_2,-(r14)
1156 000281D7 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1157 000281D7 0d effffff76b 7e movl _sgl_value_1,-(r14)
1158 000281DE # /*
1159 000281DE # * now pop the data off the stack
1160 000281DE # */
1161 000281DE #
1162 000281DE # asm("cvlf (r14)+"); /* load (negate) the data */
1163 000281DE 76 8e cvlf (r14)+
1164 000281E0 # asm("stf r5"); /* store the result */
1165 000281E0 26 55 stf r5
1166 000281E2 # asm("mulf (r14)+"); /* multipy by '1' */
1167 000281E2 e6 8e mulf (r14)+
1168 000281E4 # asm("stf r6"); /* store the result */
1169 000281E4 26 56 stf r6
1170 000281E6 # if( force_loop )
1171 000281E6 5d effffff75c tstl _force_loop
1172 000281EC 31 02 jeql L345
1173 000281EE # asm("brb _pipe3_9_lp1");; /* loop on the error */
1174 000281EE 11 d9 brb _pipe3_9_lp1
1175 000281F0 L345:
1176 000281F0 # /*
1177 000281F0 # * verify the results
1178 000281F0 # */
1179 000281F0 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1180 000281F0 0d 55 effffff751 movl r5,_sgl_st_acc
1181 000281F7 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1182 000281F7 0d 56 effffff74a movl r6,_sgl_value_6
1183 000281FE # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1184 000281FE ed 6e effffff743 moval (r14),_sgl_value_5
1185 00028205 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1186 00028205 # (sgl_value_6 != sgl_expected) ||
1187 00028205 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1188 00028205 1d effffff73d effffff738 cmpl _sgl_st_acc,_sgl_expected
1189 00028210 21 1d jneq L9991
1190 00028212 1d effffff730 effffff72b cmpl _sgl_value_6,_sgl_expected
1191 0002821D 21 10 jneq L9991
1192 0002821F 1d effffff723 effffff71e cmpl _sgl_value_5,_sgl_value_4
1193 0002822A 21 03 13 0091 jeql L346
1194 0002822F L9991:
1195 0002822F # {
1196 0002822F # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1197 0002822F 0d effffff713 5d movl _pre_event_fp,r13
1198 00028236 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1199 00028236 0d effffff70c 5e movl _pre_event_sp,r14
1200 0002823D # errcnt++; /* bump the error count */
1201 0002823D 6d effffff705 incl _errcnt
1202 00028243 # if ( prt_error ) {
1203 00028243 5d effffff6ff tstl _prt_error
1204 00028249 31 4e jeql L347
1205 0002824B # print_pipe3_er("Pop data from the STACK");
1206 0002824B .data 1
1207 00000d93 * L348:
1208 00000d93 * 506F7020646174612066726F6 .ascii "Pop data from the STACK\0"
D2074686520535441434B00
1209 00000dab * .text
1210 0002824B dd 8f00000d93 pushl $L348
1211 00028251 fe 08 ef0000025e callf $8,_print_pipe3_er
1212 00028258 # writes("final Stack Pointer = ");
1213 00028258 .data 1
1214 00000dab * L349:
1215 00000dab * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1216 00000dc2 * .text
1217 00028258 dd 8f00000dab pushl $L349
1218 0002825E fe 08 effffff6e3 callf $8,_writes
1219 00028265 # write32h( sgl_value_5 );
1220 00028265 dd effffff6dd pushl _sgl_value_5
1221 0002826B fe 08 effffff6d6 callf $8,_write32h
1222 00028272 # writes(", expected = ");
1223 00028272 .data 1
1224 00000dc2 * L351:
1225 00000dc2 * 2C20206578706563746564203 .ascii ", expected = \0"
D2000
1226 00000dd1 * .text
1227 00028272 dd 8f00000dc2 pushl $L351
1228 00028278 fe 08 effffff6c9 callf $8,_writes
1229 0002827F # write32h( sgl_value_4 );
1230 0002827F dd effffff6c3 pushl _sgl_value_4
1231 00028285 fe 08 effffff6bc callf $8,_write32h
1232 0002828C # writes(" \n");
1233 0002828C .data 1
1234 00000dd1 * L352:
1235 00000dd1 * 200A00 .ascii " \12\0"
1236 00000dd4 * .text
1237 0002828C dd 8f00000dd1 pushl $L352
1238 00028292 fe 08 effffff6af callf $8,_writes
1239 00028299 # }
1240 00028299 # if ( halt_flg )
1241 00028299 L347:
1242 00028299 5d effffff6a9 tstl _halt_flg
1243 0002829F 31 0d jeql L353
1244 000282A1 # pipe3_er_hlt( subtest );
1245 000282A1 dd effffff6a1 pushl _subtest
1246 000282A7 fe 08 ef00000314 callf $8,_pipe3_er_hlt
1247 000282AE # if ( loop_on_err ) {
1248 000282AE L353:
1249 000282AE 5d effffff694 tstl _loop_on_err
1250 000282B4 31 0a jeql L354
1251 000282B6 # force_loop = TRUE; /* set the force loop flag */
1252 000282B6 0d 01 effffff68b movl $1,_force_loop
1253 000282BD # asm("brw _pipe3_9_lp1"); /* and loop */
1254 000282BD 13 ff09 brw _pipe3_9_lp1
1255 000282C0 # }
1256 000282C0 # } /* end of compare error */
1257 000282C0 L354:
1258 000282C0 # } while( index++ < max_cvlf_1_index );
1259 000282C0 L346:
1260 000282C0 L343:
1261 000282C0 0d effffff682 50 movl _index,r0
1262 000282C7 6d effffff67b incl _index
1263 000282CD 1d 50 effffff674 cmpl r0,_max_cvlf_1_index
1264 000282D4 81 03 13 feae jlss L344
1265 000282D9 L342:
1266 000282D9 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1267 000282D9 0d effffff669 5d movl _pre_event_fp,r13
1268 000282E0 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1269 000282E0 0d effffff662 5e movl _pre_event_sp,r14
1270 000282E7 # } /* end of subtest 9 */
1271 000282E7 40 ret#2
1272 000282E8 .set L338,0x0
1273 000282E8 L340:
1274 000282E8 13 fe82 jbr L341
1275 000282EB .data
1276 00000ce8 * .text
1277 000282EB 00 .align 1
1278 000282EC .globl _pipe3_10
1279 000282EC _pipe3_10:
1280 000282EC 0000 .word L355
1281 000282EE #
1282 000282EE #
1283 000282EE #
1284 000282EE #
1285 000282EE #
1286 000282EE #
1287 000282EE # /******************************************************************************
1288 000282EE # *
1289 000282EE # * SUBTEST 10
1290 000282EE # * get data via indexed FRAME pointer
1291 000282EE # *
1292 000282EE # * ADDR INDEX DATA
1293 000282EE # * pointer_data 4 <the 1st STF result goes here>
1294 000282EE # * pointer_data-4 3 <the 2nd STF result goes here>
1295 000282EE # * pointer_data-8 2 <operand data>
1296 000282EE # * pointer_data-12 1 <floating '1'>
1297 000282EE # * pointer_data-16 0 point the frame pointer here
1298 000282EE # *
1299 000282EE # ******************************************************************************/
1300 000282EE # pipe3_10()
1301 000282EE # {
1302 000282EE 13 01c2 jbr L357
1303 000282F1 L358:
1304 000282F1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1305 000282F1 ed 6d effffff650 moval (r13),_pre_event_fp
1306 000282F8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1307 000282F8 ed 6e effffff649 moval (r14),_pre_event_sp
1308 000282FF # force_loop = FALSE; /* clear force_loop flag */
1309 000282FF 4d effffff643 clrl _force_loop
1310 00028305 # index = 0;
1311 00028305 4d effffff63d clrl _index
1312 0002830B # do
1313 0002830B L361:
1314 0002830B # {
1315 0002830B # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1316 0002830B 0d effffff637 50 movl _index,r0
1317 00028312 48 03 50 50 shll $3,r0,r0
1318 00028316 0d e000000000 effffff627 movl _cvlf_1_data(r0),_sgl_value_1
1319 00028321 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1320 00028321 0d effffff621 50 movl _index,r0
1321 00028328 48 03 50 50 shll $3,r0,r0
1322 0002832C 0d e000000004 effffff611 movl _cvlf_1_data+4(r0),_sgl_expected
1323 00028337 # sgl_value_2 = 0x40800000; /* floating '1' */
1324 00028337 0d 8f40800000 effffff606 movl $1082130432,_sgl_value_2
1325 00028342 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1326 00028342 ed effffff600 effffff5fb moval _pointer_data,_sgl_value_4
1327 0002834D # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1328 0002834D 2c 08 effffff5f4 subl2 $8,_sgl_value_4
1329 00028354 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1330 00028354 0d effffff5ee fffffff5e9 movl _sgl_value_1,*_sgl_value_4
1331 0002835F # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1332 0002835F 2c 04 effffff5e2 subl2 $4,_sgl_value_4
1333 00028366 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '1' */
1334 00028366 0d effffff5dc fffffff5d7 movl _sgl_value_2,*_sgl_value_4
1335 00028371 # sgl_value_4 -= 4; /* get FRAME PTR address */
1336 00028371 2c 04 effffff5d0 subl2 $4,_sgl_value_4
1337 00028378 # /*
1338 00028378 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1339 00028378 # * The force loop flag is set after the first error.
1340 00028378 # */
1341 00028378 # asm("_pipe3_10_lp1:");
1342 00028378 _pipe3_10_lp1:
1343 00028378 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1344 00028378 0d effffff5ca 5d movl _sgl_value_4,r13
1345 0002837F # asm("movl $1,r1"); /* r1 index = 1 longwords */
1346 0002837F 0d 01 51 movl $1,r1
1347 00028382 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1348 00028382 0d 02 52 movl $2,r2
1349 00028385 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1350 00028385 0d 03 53 movl $3,r3
1351 00028388 # asm("movl $4,r4"); /* r4 index = 4 longwords */
1352 00028388 0d 04 54 movl $4,r4
1353 0002838B # asm("cvlf (r13)[r2]"); /* load the op (indx = 2) */
1354 0002838B 76 426d cvlf (r13)[r2]
1355 0002838E # asm("stf (r13)[r4]"); /* store -indexed by r4 */
1356 0002838E 26 446d stf (r13)[r4]
1357 00028391 # asm("mulf (r13)[r1]"); /* multiply by '1' (indx=1) */
1358 00028391 e6 416d mulf (r13)[r1]
1359 00028394 # asm("stf (r13)[r3]"); /* store -indexed by r3 */
1360 00028394 26 436d stf (r13)[r3]
1361 00028397 # if( force_loop )
1362 00028397 5d effffff5ab tstl _force_loop
1363 0002839D 31 02 jeql L362
1364 0002839F # asm("brb _pipe3_10_lp1");; /* loop on the error */
1365 0002839F 11 d7 brb _pipe3_10_lp1
1366 000283A1 L362:
1367 000283A1 # /*
1368 000283A1 # * verify the results
1369 000283A1 # */
1370 000283A1 # sgl_st_acc = pointer_data; /* save 1st stored value */
1371 000283A1 0d effffff5a1 effffff59c movl _pointer_data,_sgl_st_acc
1372 000283AC # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1373 000283AC ed effffff596 effffff591 moval _pointer_data,_sgl_value_5
1374 000283B7 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1375 000283B7 2c 04 effffff58a subl2 $4,_sgl_value_5
1376 000283BE # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1377 000283BE 0d fffffff584 effffff57f movl *_sgl_value_5,_sgl_value_6
1378 000283C9 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1379 000283C9 ed 6d effffff578 moval (r13),_sgl_value_5
1380 000283D0 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1381 000283D0 # (sgl_value_6 != sgl_expected) ||
1382 000283D0 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1383 000283D0 1d effffff572 effffff56d cmpl _sgl_st_acc,_sgl_expected
1384 000283DB 21 1d jneq L9990
1385 000283DD 1d effffff565 effffff560 cmpl _sgl_value_6,_sgl_expected
1386 000283E8 21 10 jneq L9990
1387 000283EA 1d effffff558 effffff553 cmpl _sgl_value_5,_sgl_value_4
1388 000283F5 21 03 13 0091 jeql L363
1389 000283FA L9990:
1390 000283FA # {
1391 000283FA # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1392 000283FA 0d effffff548 5d movl _pre_event_fp,r13
1393 00028401 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1394 00028401 0d effffff541 5e movl _pre_event_sp,r14
1395 00028408 # errcnt++; /* bump the error count */
1396 00028408 6d effffff53a incl _errcnt
1397 0002840E # if ( prt_error ) {
1398 0002840E 5d effffff534 tstl _prt_error
1399 00028414 31 4e jeql L364
1400 00028416 # print_pipe3_er("indexed FP addressing");
1401 00028416 .data 1
1402 00000dd4 * L365:
1403 00000dd4 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1404 00000dea * .text
1405 00028416 dd 8f00000dd4 pushl $L365
1406 0002841C fe 08 ef00000093 callf $8,_print_pipe3_er
1407 00028423 # writes("final Frame Pointer = ");
1408 00028423 .data 1
1409 00000dea * L366:
1410 00000dea * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1411 00000e01 * .text
1412 00028423 dd 8f00000dea pushl $L366
1413 00028429 fe 08 effffff518 callf $8,_writes
1414 00028430 # writeh( sgl_value_5 );
1415 00028430 dd effffff512 pushl _sgl_value_5
1416 00028436 fe 08 effffff50b callf $8,_writeh
1417 0002843D # writes(", expected FP = ");
1418 0002843D .data 1
1419 00000e01 * L368:
1420 00000e01 * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1421 00000e13 * .text
1422 0002843D dd 8f00000e01 pushl $L368
1423 00028443 fe 08 effffff4fe callf $8,_writes
1424 0002844A # writeh( sgl_value_4 );
1425 0002844A dd effffff4f8 pushl _sgl_value_4
1426 00028450 fe 08 effffff4f1 callf $8,_writeh
1427 00028457 # writes(" \n");
1428 00028457 .data 1
1429 00000e13 * L369:
1430 00000e13 * 200A00 .ascii " \12\0"
1431 00000e16 * .text
1432 00028457 dd 8f00000e13 pushl $L369
1433 0002845D fe 08 effffff4e4 callf $8,_writes
1434 00028464 # }
1435 00028464 # if ( halt_flg )
1436 00028464 L364:
1437 00028464 5d effffff4de tstl _halt_flg
1438 0002846A 31 0d jeql L370
1439 0002846C # pipe3_er_hlt( subtest );
1440 0002846C dd effffff4d6 pushl _subtest
1441 00028472 fe 08 ef00000149 callf $8,_pipe3_er_hlt
1442 00028479 # if ( loop_on_err ) {
1443 00028479 L370:
1444 00028479 5d effffff4c9 tstl _loop_on_err
1445 0002847F 31 0a jeql L371
1446 00028481 # force_loop = TRUE; /* set the force loop flag */
1447 00028481 0d 01 effffff4c0 movl $1,_force_loop
1448 00028488 # asm("brw _pipe3_10_lp1"); /* and loop */
1449 00028488 13 feed brw _pipe3_10_lp1
1450 0002848B # }
1451 0002848B # } /* end of compare error */
1452 0002848B L371:
1453 0002848B # } while( index++ < max_cvlf_1_index );
1454 0002848B L363:
1455 0002848B L360:
1456 0002848B 0d effffff4b7 50 movl _index,r0
1457 00028492 6d effffff4b0 incl _index
1458 00028498 1d 50 effffff4a9 cmpl r0,_max_cvlf_1_index
1459 0002849F 81 03 13 fe67 jlss L361
1460 000284A4 L359:
1461 000284A4 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1462 000284A4 0d effffff49e 5d movl _pre_event_fp,r13
1463 000284AB # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1464 000284AB 0d effffff497 5e movl _pre_event_sp,r14
1465 000284B2 # } /* end of subtest 10 */
1466 000284B2 40 ret#2
1467 000284B3 .set L355,0x0
1468 000284B3 L357:
1469 000284B3 13 fe3b jbr L358
1470 000284B6 .data
1471 00000ce8 * .text
1472 000284B6 .align 1
1473 000284B6 .globl _print_pipe3_er
1474 000284B6 _print_pipe3_er:
1475 000284B6 0000 .word L372
1476 000284B8 #
1477 000284B8 #
1478 000284B8 # /******************************************************************************
1479 000284B8 # *
1480 000284B8 # *
1481 000284B8 # * print an error in the following form
1482 000284B8 # *
1483 000284B8 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1484 000284B8 # * expected Acc = xxxxxxxx
1485 000284B8 # *
1486 000284B8 # ******************************************************************************/
1487 000284B8 # print_pipe3_er(msg)
1488 000284B8 # char *msg;
1489 000284B8 # {
1490 000284B8 13 0103 jbr L374
1491 000284BB L375:
1492 000284BB # writes(" \n"); /* start a new print line */
1493 000284BB .data 1
1494 00000e16 * L376:
1495 00000e16 * 200A00 .ascii " \12\0"
1496 00000e19 * .text
1497 000284BB dd 8f00000e16 pushl $L376
1498 000284C1 fe 08 effffff480 callf $8,_writes
1499 000284C8 # writes("cycle: ");
1500 000284C8 .data 1
1501 00000e19 * L377:
1502 00000e19 * 6379636C653A2000 .ascii "cycle: \0"
1503 00000e21 * .text
1504 000284C8 dd 8f00000e19 pushl $L377
1505 000284CE fe 08 effffff473 callf $8,_writes
1506 000284D5 # writed( cycle );
1507 000284D5 dd effffff46d pushl _cycle
1508 000284DB fe 08 effffff466 callf $8,_writed
1509 000284E2 # writes(" test ");
1510 000284E2 .data 1
1511 00000e21 * L379:
1512 00000e21 * 20746573742000 .ascii " test \0"
1513 00000e28 * .text
1514 000284E2 dd 8f00000e21 pushl $L379
1515 000284E8 fe 08 effffff459 callf $8,_writes
1516 000284EF # writed( test_no );
1517 000284EF dd effffff453 pushl _test_no
1518 000284F5 fe 08 effffff44c callf $8,_writed
1519 000284FC # writes(" (Pipe 3), subtest ");
1520 000284FC .data 1
1521 00000e28 * L380:
1522 00000e28 * 202028506970652033292C207 .ascii " (Pipe 3), subtest \0"
37562746573742000
1523 00000e3d * .text
1524 000284FC dd 8f00000e28 pushl $L380
1525 00028502 fe 08 effffff43f callf $8,_writes
1526 00028509 # writed( subtest );
1527 00028509 dd effffff439 pushl _subtest
1528 0002850F fe 08 effffff432 callf $8,_writed
1529 00028516 # writes(" error - ");
1530 00028516 .data 1
1531 00000e3d * L381:
1532 00000e3d * 206572726F72202D2000 .ascii " error - \0"
1533 00000e47 * .text
1534 00028516 dd 8f00000e3d pushl $L381
1535 0002851C fe 08 effffff425 callf $8,_writes
1536 00028523 # writes( msg );
1537 00028523 dd ad04 pushl 4(fp)
1538 00028526 fe 08 effffff41b callf $8,_writes
1539 0002852D # writec('\n');
1540 0002852D dd 0a pushl $10
1541 0002852F fe 08 effffff412 callf $8,_writec
1542 00028536 # writes(" CVLF(op), STF, MULF(1.0), STF\n");
1543 00028536 .data 1
1544 00000e47 * L383:
1545 00000e47 * 2043564C46286F70292C20535 .ascii " CVLF(op), STF, MULF(1.0), STF\12\0"
4462C204D554C4628312E3029
2C205354460A00
1546 00000e67 * .text
1547 00028536 dd 8f00000e47 pushl $L383
1548 0002853C fe 08 effffff405 callf $8,_writes
1549 00028543 # writes("operand = ");
1550 00028543 .data 1
1551 00000e67 * L384:
1552 00000e67 * 6F706572616E64203D2000 .ascii "operand = \0"
1553 00000e72 * .text
1554 00028543 dd 8f00000e67 pushl $L384
1555 00028549 fe 08 effffff3f8 callf $8,_writes
1556 00028550 # write32h( sgl_value_1 );
1557 00028550 dd effffff3f2 pushl _sgl_value_1
1558 00028556 fe 08 effffff3eb callf $8,_write32h
1559 0002855D # writes(", final Acc = ");
1560 0002855D .data 1
1561 00000e72 * L385:
1562 00000e72 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1563 00000e83 * .text
1564 0002855D dd 8f00000e72 pushl $L385
1565 00028563 fe 08 effffff3de callf $8,_writes
1566 0002856A # write32h( sgl_st_acc );
1567 0002856A dd effffff3d8 pushl _sgl_st_acc
1568 00028570 fe 08 effffff3d1 callf $8,_write32h
1569 00028577 # writes(", data index = ");
1570 00028577 .data 1
1571 00000e83 * L386:
1572 00000e83 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1573 00000e95 * .text
1574 00028577 dd 8f00000e83 pushl $L386
1575 0002857D fe 08 effffff3c4 callf $8,_writes
1576 00028584 # writed( index );
1577 00028584 dd effffff3be pushl _index
1578 0002858A fe 08 effffff3b7 callf $8,_writed
1579 00028591 # writec('\n');
1580 00028591 dd 0a pushl $10
1581 00028593 fe 08 effffff3ae callf $8,_writec
1582 0002859A # writes(" expected Acc = ");
1583 0002859A .data 1
1584 00000e95 * L387:
1585 00000e95 * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020657870656374
656420416363203D2000
1586 00000eb8 * .text
1587 0002859A dd 8f00000e95 pushl $L387
1588 000285A0 fe 08 effffff3a1 callf $8,_writes
1589 000285A7 # write32h( sgl_expected );
1590 000285A7 dd effffff39b pushl _sgl_expected
1591 000285AD fe 08 effffff394 callf $8,_write32h
1592 000285B4 # writec('\n');
1593 000285B4 dd 0a pushl $10
1594 000285B6 fe 08 effffff38b callf $8,_writec
1595 000285BD # }
1596 000285BD 40 ret#2
1597 000285BE .set L372,0x0
1598 000285BE L374:
1599 000285BE 13 fefa jbr L375
1600 000285C1 .data
1601 00000ce8 * .text
1602 000285C1 00 .align 1
1603 000285C2 .globl _pipe3_er_hlt
1604 000285C2 _pipe3_er_hlt:
1605 000285C2 0000 .word L388
1606 000285C4 #
1607 000285C4 #
1608 000285C4 #
1609 000285C4 #
1610 000285C4 #
1611 000285C4 # /******************************************************************************
1612 000285C4 # *
1613 000285C4 # * HALT ON ERROR ROUTINE
1614 000285C4 # *
1615 000285C4 # * halt with the necessary information saved in the registers
1616 000285C4 # *
1617 000285C4 # ******************************************************************************/
1618 000285C4 # pipe3_er_hlt( subtest )
1619 000285C4 # int subtest;
1620 000285C4 # {
1621 000285C4 11 67 jbr L390
1622 000285C6 L391:
1623 000285C6 # asm("movl _test_no,r0"); /* r0 = test number */
1624 000285C6 0d effffff37c 50 movl _test_no,r0
1625 000285CD # asm("movl _subtest,r1"); /* r1 = subtest number */
1626 000285CD 0d effffff375 51 movl _subtest,r1
1627 000285D4 # asm("movl $1,r2"); /* r2 = error code */
1628 000285D4 0d 01 52 movl $1,r2
1629 000285D7 # asm("movl _cycle,r3"); /* r3 = cycle count */
1630 000285D7 0d effffff36b 53 movl _cycle,r3
1631 000285DE # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1632 000285DE 0d effffff364 54 movl _sgl_value_1,r4
1633 000285E5 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1634 000285E5 0d effffff35d 55 movl _sgl_st_acc,r5
1635 000285EC # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1636 000285EC 0d effffff356 56 movl _sgl_expected,r6
1637 000285F3 # asm("movl _index,r7"); /* r7 = data index */
1638 000285F3 0d effffff34f 57 movl _index,r7
1639 000285FA # asm("movl _sgl_value_2,r8"); /* r8 = floating one */
1640 000285FA 0d effffff348 58 movl _sgl_value_2,r8
1641 00028601 # if( subtest == 9 ) {
1642 00028601 1d ad04 09 cmpl 4(fp),$9
1643 00028605 21 10 jneq L392
1644 00028607 # asm("movl _sgl_value_5,r9"); /* r9 = final SP value */
1645 00028607 0d effffff33b 59 movl _sgl_value_5,r9
1646 0002860E # asm("movl _sgl_value_4,r10"); /* r10= expected SP value */
1647 0002860E 0d effffff334 5a movl _sgl_value_4,r10
1648 00028615 # } else
1649 00028615 11 14 jbr L393
1650 00028617 L392:
1651 00028617 # if( subtest == 10 ) {
1652 00028617 1d ad04 0a cmpl 4(fp),$10
1653 0002861B 21 0e jneq L394
1654 0002861D # asm("movl _sgl_value_5,r9"); /* r9 = final FP value */
1655 0002861D 0d effffff325 59 movl _sgl_value_5,r9
1656 00028624 # asm("movl _sgl_value_4,r10"); /* r10= expected FP value */
1657 00028624 0d effffff31e 5a movl _sgl_value_4,r10
1658 0002862B # };
1659 0002862B L394:
1660 0002862B L393:
1661 0002862B # asm(".globl _pipe3_1_hlt");
1662 0002862B .globl _pipe3_1_hlt
1663 0002862B # asm("_pipe3_1_hlt:"); /* PC after the halt */
1664 0002862B _pipe3_1_hlt:
1665 0002862B # asm("halt"); /* HALT ... */
1666 0002862B 00 halt
1667 0002862C # } /* end of halt on error */
1668 0002862C 40 ret#2
1669 0002862D .set L388,0x0
1670 0002862D L390:
1671 0002862D 11 97 jbr L391
1672 0002862F .data
1672 0004FF77 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.