![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe5.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 pipe5.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 00000d0c * .text
4 00000000 .align 1
5 00000000 .globl _pipe_5
6 00000000 _pipe_5:
7 000293A8 0000 .word L215
8 000293AA # #include "fpp_defs.h"
9 000293AA #
10 000293AA #
11 000293AA # /*****************************************************************************
12 000293AA # *
13 000293AA # * PIPELINE TEST #5 MONITOR
14 000293AA # *
15 000293AA # * This test will do:
16 000293AA # *
17 000293AA # * LNF(x) STF LNF(0) SUBF(x) STF
18 000293AA # *
19 000293AA # * where x is the fmacro1 LNF data. This test verifies the store after the
20 000293AA # * LNF and the LNF after the store.
21 000293AA # *****************************************************************************/
22 000293AA # pipe_5()
23 000293AA # {
24 000293AA 13 00a8 jbr L217
25 000293AD L218:
26 000293AD # asm(".globl _pipeline_5_t");
27 000293AD .globl _pipeline_5_t
28 000293AD # asm("_pipeline_5_t:"); /* entry address */
29 000293AD _pipeline_5_t:
30 000293AD # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
31 000293AD 1d effffffff5 01 cmpl _cycle,$1
32 000293B4 21 15 jneq L219
33 000293B6 5d efffffffec tstl _prt_hdrs
34 000293BC 31 0d jeql L219
35 000293BE # {
36 000293BE # writes(" PIPE_5 ");
37 000293BE .data 1
38 00000d0c * L221:
39 00000d0c * 20504950455F352000 .ascii " PIPE_5 \0"
40 00000d15 * .text
41 000293BE dd 8f00000d0c pushl $L221
42 000293C4 fe 08 efffffffdd callf $8,_writes
43 000293CB # }
44 000293CB # subtest = 1;
45 000293CB L219:
46 000293CB 0d 01 efffffffd6 movl $1,_subtest
47 000293D2 # pipe5_1(); /* data in REGs, no NOPs */
48 000293D2 fe 04 ef0000007f callf $4,_pipe5_1
49 000293D9 # subtest++; /* increment subtest num */
50 000293D9 6d efffffffc9 incl _subtest
51 000293DF # pipe5_2(); /* data in REGs, 1 NOP */
52 000293DF fe 04 ef0000015e callf $4,_pipe5_2
53 000293E6 # subtest++; /* increment subtest num */
54 000293E6 6d efffffffbc incl _subtest
55 000293EC # pipe5_3(); /* data in REGs, 2 NOPs */
56 000293EC fe 04 ef00000241 callf $4,_pipe5_3
57 000293F3 # subtest++; /* increment subtest num */
58 000293F3 6d efffffffaf incl _subtest
59 000293F9 # pipe5_4(); /* data in REGs, 3 NOPs */
60 000293F9 fe 04 ef00000328 callf $4,_pipe5_4
61 00029400 # subtest++; /* increment subtest num */
62 00029400 6d efffffffa2 incl _subtest
63 00029406 # pipe5_5(); /* data in CACHE, no NOPs */
64 00029406 fe 04 ef00000413 callf $4,_pipe5_5
65 0002940D # subtest++; /* increment subtest num */
66 0002940D 6d efffffff95 incl _subtest
67 00029413 # pipe5_6(); /* data in CACHE, 1 NOP */
68 00029413 fe 04 ef000004ea callf $4,_pipe5_6
69 0002941A # subtest++; /* increment subtest num */
70 0002941A 6d efffffff88 incl _subtest
71 00029420 # pipe5_7(); /* data in CACHE, 2 NOPs */
72 00029420 fe 04 ef000005c5 callf $4,_pipe5_7
73 00029427 # subtest++; /* increment subtest num */
74 00029427 6d efffffff7b incl _subtest
75 0002942D # pipe5_8(); /* data in CACHE, 3 NOPs */
76 0002942D fe 04 ef000006a4 callf $4,_pipe5_8
77 00029434 # subtest++; /* increment subtest num */
78 00029434 6d efffffff6e incl _subtest
79 0002943A # pipe5_9(); /* data on STACK, no NOPs */
80 0002943A fe 04 ef00000787 callf $4,_pipe5_9
81 00029441 # subtest++; /* increment subtest num */
82 00029441 6d efffffff61 incl _subtest
83 00029447 # pipe5_10(); /* data via FP no NOPs */
84 00029447 fe 04 ef00000902 callf $4,_pipe5_10
85 0002944E # asm("jmp *return"); /* return to the test monitor */
86 0002944E 71 ffffffff54 jmp *return
87 00029454 # }
88 00029454 40 ret#2
89 00029455 .set L215,0x0
90 00029455 L217:
91 00029455 13 ff55 jbr L218
92 00029458 .data
93 00000d0c * .text
94 00029458 .align 1
95 00029458 .globl _pipe5_1
96 00029458 _pipe5_1:
97 00029458 0000 .word L232
98 0002945A #
99 0002945A #
100 0002945A #
101 0002945A #
102 0002945A #
103 0002945A #
104 0002945A # /************************************************************************
105 0002945A # *
106 0002945A # * SUBTEST 1
107 0002945A # * data in registers, no NO-OPs
108 0002945A # *
109 0002945A # ************************************************************************/
110 0002945A # pipe5_1()
111 0002945A # {
112 0002945A 13 00e4 jbr L234
113 0002945D L235:
114 0002945D # force_loop = FALSE; /* clear force_loop flag */
115 0002945D 4d efffffff45 clrl _force_loop
116 00029463 # index = 0;
117 00029463 4d efffffff3f clrl _index
118 00029469 # do
119 00029469 L238:
120 00029469 # {
121 00029469 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
122 00029469 0d efffffff39 50 movl _index,r0
123 00029470 48 03 50 50 shll $3,r0,r0
124 00029474 0d e000000000 efffffff29 movl _lnf_1_data(r0),_sgl_value_1
125 0002947F # sgl_expected = lnf_1_data[index].exp; /* get expected results */
126 0002947F 0d efffffff23 50 movl _index,r0
127 00029486 48 03 50 50 shll $3,r0,r0
128 0002948A 0d e000000004 efffffff13 movl _lnf_1_data+4(r0),_sgl_expected
129 00029495 # sgl_value_2 = 0; /* floating '0' */
130 00029495 4d efffffff0d clrl _sgl_value_2
131 0002949B # /*
132 0002949B # * If LOOP ON ERROR is set, this is the loop for this subtest.
133 0002949B # * The force loop flag is set after the first error.
134 0002949B # */
135 0002949B # asm("_pipe5_1_lp1:");
136 0002949B _pipe5_1_lp1:
137 0002949B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
138 0002949B 0d efffffff07 54 movl _sgl_value_1,r4
139 000294A2 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
140 000294A2 0d efffffff00 55 movl _sgl_value_2,r5
141 000294A9 # asm("lnf r4"); /* load the operand */
142 000294A9 16 54 lnf r4
143 000294AB # asm("stf r7"); /* store the result */
144 000294AB 26 57 stf r7
145 000294AD # asm("lnf r5"); /* load a floating '0' */
146 000294AD 16 55 lnf r5
147 000294AF # asm("subf r4"); /* subtract the operand */
148 000294AF d6 54 subf r4
149 000294B1 # asm("stf r8"); /* store the result */
150 000294B1 26 58 stf r8
151 000294B3 # if( force_loop )
152 000294B3 5d effffffeef tstl _force_loop
153 000294B9 31 02 jeql L239
154 000294BB # asm("brb _pipe5_1_lp1");; /* loop on the error */
155 000294BB 11 de brb _pipe5_1_lp1
156 000294BD L239:
157 000294BD # /*
158 000294BD # * verify the results
159 000294BD # */
160 000294BD # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
161 000294BD 0d 57 effffffee4 movl r7,_sgl_st_acc
162 000294C4 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
163 000294C4 0d 58 effffffedd movl r8,_sgl_value_6
164 000294CB # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
165 000294CB # (sgl_value_6 != sgl_expected) )
166 000294CB 1d effffffed7 effffffed2 cmpl _sgl_st_acc,_sgl_expected
167 000294D6 21 0d jneq L9999
168 000294D8 1d effffffeca effffffec5 cmpl _sgl_value_6,_sgl_expected
169 000294E3 31 42 jeql L240
170 000294E5 L9999:
171 000294E5 # {
172 000294E5 # errcnt++; /* bump the error count */
173 000294E5 6d effffffebd incl _errcnt
174 000294EB # if ( prt_error )
175 000294EB 5d effffffeb7 tstl _prt_error
176 000294F1 31 0d jeql L241
177 000294F3 # print_pipe5_er("Reg. Data, no NO-OPs");
178 000294F3 .data 1
179 00000d15 * L243:
180 00000d15 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
F204E4F2D4F507300
181 00000d2a * .text
182 000294F3 dd 8f00000d15 pushl $L243
183 000294F9 fe 08 ef00000a18 callf $8,_print_pipe5_er
184 00029500 # if ( halt_flg )
185 00029500 L241:
186 00029500 5d effffffea2 tstl _halt_flg
187 00029506 31 0d jeql L244
188 00029508 # pipe5_er_hlt( subtest );
189 00029508 dd effffffe9a pushl _subtest
190 0002950E fe 08 ef00000b29 callf $8,_pipe5_er_hlt
191 00029515 # if ( loop_on_err ) {
192 00029515 L244:
193 00029515 5d effffffe8d tstl _loop_on_err
194 0002951B 31 0a jeql L246
195 0002951D # force_loop = TRUE; /* set the force loop flag */
196 0002951D 0d 01 effffffe84 movl $1,_force_loop
197 00029524 # asm("brw _pipe5_1_lp1"); /* and loop */
198 00029524 13 ff74 brw _pipe5_1_lp1
199 00029527 # }
200 00029527 # } /* end of compare error */
201 00029527 L246:
202 00029527 # } while( index++ < max_lnf_1_index );
203 00029527 L240:
204 00029527 L237:
205 00029527 0d effffffe7b 50 movl _index,r0
206 0002952E 6d effffffe74 incl _index
207 00029534 1d 50 effffffe6d cmpl r0,_max_lnf_1_index
208 0002953B 81 03 13 ff29 jlss L238
209 00029540 L236:
210 00029540 # } /* end of subtest 1 */
211 00029540 40 ret#2
212 00029541 .set L232,0x0
213 00029541 L234:
214 00029541 13 ff19 jbr L235
215 00029544 .data
216 00000d0c * .text
217 00029544 .align 1
218 00029544 .globl _pipe5_2
219 00029544 _pipe5_2:
220 00029544 0000 .word L247
221 00029546 #
222 00029546 #
223 00029546 #
224 00029546 #
225 00029546 #
226 00029546 #
227 00029546 # /************************************************************************
228 00029546 # *
229 00029546 # * SUBTEST 2
230 00029546 # * data in registers, 1 NO-OP
231 00029546 # *
232 00029546 # ************************************************************************/
233 00029546 # pipe5_2()
234 00029546 # {
235 00029546 13 00e8 jbr L249
236 00029549 L250:
237 00029549 # force_loop = FALSE; /* clear force_loop flag */
238 00029549 4d effffffe59 clrl _force_loop
239 0002954F # index = 0;
240 0002954F 4d effffffe53 clrl _index
241 00029555 # do
242 00029555 L253:
243 00029555 # {
244 00029555 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
245 00029555 0d effffffe4d 50 movl _index,r0
246 0002955C 48 03 50 50 shll $3,r0,r0
247 00029560 0d e000000000 effffffe3d movl _lnf_1_data(r0),_sgl_value_1
248 0002956B # sgl_expected = lnf_1_data[index].exp; /* get expected results */
249 0002956B 0d effffffe37 50 movl _index,r0
250 00029572 48 03 50 50 shll $3,r0,r0
251 00029576 0d e000000004 effffffe27 movl _lnf_1_data+4(r0),_sgl_expected
252 00029581 # sgl_value_2 = 0x00000000; /* floating '0' */
253 00029581 4d effffffe21 clrl _sgl_value_2
254 00029587 # /*
255 00029587 # * If LOOP ON ERROR is set, this is the loop for this subtest.
256 00029587 # * The force loop flag is set after the first error.
257 00029587 # */
258 00029587 # asm("_pipe5_2_lp1:");
259 00029587 _pipe5_2_lp1:
260 00029587 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
261 00029587 0d effffffe1b 54 movl _sgl_value_1,r4
262 0002958E # asm("movl _sgl_value_2,r5"); /* move data to r5 */
263 0002958E 0d effffffe14 55 movl _sgl_value_2,r5
264 00029595 # asm("lnf r4"); /* load the operand */
265 00029595 16 54 lnf r4
266 00029597 # asm("nop");
267 00029597 10 nop
268 00029598 # asm("stf r7"); /* store the result */
269 00029598 26 57 stf r7
270 0002959A # asm("nop");
271 0002959A 10 nop
272 0002959B # asm("lnf r5"); /* load a floating '0' */
273 0002959B 16 55 lnf r5
274 0002959D # asm("nop");
275 0002959D 10 nop
276 0002959E # asm("subf r4"); /* subtract the operand */
277 0002959E d6 54 subf r4
278 000295A0 # asm("nop");
279 000295A0 10 nop
280 000295A1 # asm("stf r8"); /* store the result */
281 000295A1 26 58 stf r8
282 000295A3 # if( force_loop )
283 000295A3 5d effffffdff tstl _force_loop
284 000295A9 31 02 jeql L254
285 000295AB # asm("brb _pipe5_2_lp1");; /* loop on the error */
286 000295AB 11 da brb _pipe5_2_lp1
287 000295AD L254:
288 000295AD # /*
289 000295AD # * verify the results
290 000295AD # */
291 000295AD # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
292 000295AD 0d 57 effffffdf4 movl r7,_sgl_st_acc
293 000295B4 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
294 000295B4 0d 58 effffffded movl r8,_sgl_value_6
295 000295BB # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
296 000295BB # (sgl_value_6 != sgl_expected) )
297 000295BB 1d effffffde7 effffffde2 cmpl _sgl_st_acc,_sgl_expected
298 000295C6 21 0d jneq L9998
299 000295C8 1d effffffdda effffffdd5 cmpl _sgl_value_6,_sgl_expected
300 000295D3 31 42 jeql L255
301 000295D5 L9998:
302 000295D5 # {
303 000295D5 # errcnt++; /* bump the error count */
304 000295D5 6d effffffdcd incl _errcnt
305 000295DB # if ( prt_error )
306 000295DB 5d effffffdc7 tstl _prt_error
307 000295E1 31 0d jeql L256
308 000295E3 # print_pipe5_er("Reg. Data, 1 NO-OP");
309 000295E3 .data 1
310 00000d2a * L257:
311 00000d2a * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
312 00000d3d * .text
313 000295E3 dd 8f00000d2a pushl $L257
314 000295E9 fe 08 ef00000928 callf $8,_print_pipe5_er
315 000295F0 # if ( halt_flg )
316 000295F0 L256:
317 000295F0 5d effffffdb2 tstl _halt_flg
318 000295F6 31 0d jeql L258
319 000295F8 # pipe5_er_hlt( subtest );
320 000295F8 dd effffffdaa pushl _subtest
321 000295FE fe 08 ef00000a39 callf $8,_pipe5_er_hlt
322 00029605 # if ( loop_on_err ) {
323 00029605 L258:
324 00029605 5d effffffd9d tstl _loop_on_err
325 0002960B 31 0a jeql L259
326 0002960D # force_loop = TRUE; /* set the force loop flag */
327 0002960D 0d 01 effffffd94 movl $1,_force_loop
328 00029614 # asm("brw _pipe5_2_lp1"); /* and loop */
329 00029614 13 ff70 brw _pipe5_2_lp1
330 00029617 # }
331 00029617 # } /* end of compare error */
332 00029617 L259:
333 00029617 # } while( index++ < max_lnf_1_index );
334 00029617 L255:
335 00029617 L252:
336 00029617 0d effffffd8b 50 movl _index,r0
337 0002961E 6d effffffd84 incl _index
338 00029624 1d 50 effffffd7d cmpl r0,_max_lnf_1_index
339 0002962B 81 03 13 ff25 jlss L253
340 00029630 L251:
341 00029630 # } /* end of subtest 2 */
342 00029630 40 ret#2
343 00029631 .set L247,0x0
344 00029631 L249:
345 00029631 13 ff15 jbr L250
346 00029634 .data
347 00000d0c * .text
348 00029634 .align 1
349 00029634 .globl _pipe5_3
350 00029634 _pipe5_3:
351 00029634 0000 .word L260
352 00029636 #
353 00029636 #
354 00029636 #
355 00029636 #
356 00029636 #
357 00029636 #
358 00029636 # /************************************************************************
359 00029636 # *
360 00029636 # * SUBTEST 3
361 00029636 # * data in registers, 2 NO-OPs
362 00029636 # *
363 00029636 # ************************************************************************/
364 00029636 # pipe5_3()
365 00029636 # {
366 00029636 13 00ec jbr L262
367 00029639 L263:
368 00029639 # force_loop = FALSE; /* clear force_loop flag */
369 00029639 4d effffffd69 clrl _force_loop
370 0002963F # index = 0;
371 0002963F 4d effffffd63 clrl _index
372 00029645 # do
373 00029645 L266:
374 00029645 # {
375 00029645 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
376 00029645 0d effffffd5d 50 movl _index,r0
377 0002964C 48 03 50 50 shll $3,r0,r0
378 00029650 0d e000000000 effffffd4d movl _lnf_1_data(r0),_sgl_value_1
379 0002965B # sgl_expected = lnf_1_data[index].exp; /* get expected results */
380 0002965B 0d effffffd47 50 movl _index,r0
381 00029662 48 03 50 50 shll $3,r0,r0
382 00029666 0d e000000004 effffffd37 movl _lnf_1_data+4(r0),_sgl_expected
383 00029671 # sgl_value_2 = 0x00000000; /* floating '0' */
384 00029671 4d effffffd31 clrl _sgl_value_2
385 00029677 # /*
386 00029677 # * If LOOP ON ERROR is set, this is the loop for this subtest.
387 00029677 # * The force loop flag is set after the first error.
388 00029677 # */
389 00029677 # asm("_pipe5_3_lp1:");
390 00029677 _pipe5_3_lp1:
391 00029677 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
392 00029677 0d effffffd2b 54 movl _sgl_value_1,r4
393 0002967E # asm("movl _sgl_value_2,r5"); /* move data to r5 */
394 0002967E 0d effffffd24 55 movl _sgl_value_2,r5
395 00029685 # asm("lnf r4"); /* load the operand */
396 00029685 16 54 lnf r4
397 00029687 # asm("nop");
398 00029687 10 nop
399 00029688 # asm("nop");
400 00029688 10 nop
401 00029689 # asm("stf r7"); /* store the result */
402 00029689 26 57 stf r7
403 0002968B # asm("nop");
404 0002968B 10 nop
405 0002968C # asm("nop");
406 0002968C 10 nop
407 0002968D # asm("lnf r5"); /* load a floating '0' */
408 0002968D 16 55 lnf r5
409 0002968F # asm("nop");
410 0002968F 10 nop
411 00029690 # asm("nop");
412 00029690 10 nop
413 00029691 # asm("subf r4"); /* subtract the operand */
414 00029691 d6 54 subf r4
415 00029693 # asm("nop");
416 00029693 10 nop
417 00029694 # asm("nop");
418 00029694 10 nop
419 00029695 # asm("stf r8"); /* store the result */
420 00029695 26 58 stf r8
421 00029697 # if( force_loop )
422 00029697 5d effffffd0b tstl _force_loop
423 0002969D 31 02 jeql L267
424 0002969F # asm("brb _pipe5_3_lp1");; /* loop on the error */
425 0002969F 11 d6 brb _pipe5_3_lp1
426 000296A1 L267:
427 000296A1 # /*
428 000296A1 # * verify the results
429 000296A1 # */
430 000296A1 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
431 000296A1 0d 57 effffffd00 movl r7,_sgl_st_acc
432 000296A8 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
433 000296A8 0d 58 effffffcf9 movl r8,_sgl_value_6
434 000296AF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
435 000296AF # (sgl_value_6 != sgl_expected) )
436 000296AF 1d effffffcf3 effffffcee cmpl _sgl_st_acc,_sgl_expected
437 000296BA 21 0d jneq L9997
438 000296BC 1d effffffce6 effffffce1 cmpl _sgl_value_6,_sgl_expected
439 000296C7 31 42 jeql L268
440 000296C9 L9997:
441 000296C9 # {
442 000296C9 # errcnt++; /* bump the error count */
443 000296C9 6d effffffcd9 incl _errcnt
444 000296CF # if ( prt_error )
445 000296CF 5d effffffcd3 tstl _prt_error
446 000296D5 31 0d jeql L269
447 000296D7 # print_pipe5_er("Reg. Data, 2 NO-OPs");
448 000296D7 .data 1
449 00000d3d * L270:
450 00000d3d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
04E4F2D4F507300
451 00000d51 * .text
452 000296D7 dd 8f00000d3d pushl $L270
453 000296DD fe 08 ef00000834 callf $8,_print_pipe5_er
454 000296E4 # if ( halt_flg )
455 000296E4 L269:
456 000296E4 5d effffffcbe tstl _halt_flg
457 000296EA 31 0d jeql L271
458 000296EC # pipe5_er_hlt( subtest );
459 000296EC dd effffffcb6 pushl _subtest
460 000296F2 fe 08 ef00000945 callf $8,_pipe5_er_hlt
461 000296F9 # if ( loop_on_err ) {
462 000296F9 L271:
463 000296F9 5d effffffca9 tstl _loop_on_err
464 000296FF 31 0a jeql L272
465 00029701 # force_loop = TRUE; /* set the force loop flag */
466 00029701 0d 01 effffffca0 movl $1,_force_loop
467 00029708 # asm("brw _pipe5_3_lp1"); /* and loop */
468 00029708 13 ff6c brw _pipe5_3_lp1
469 0002970B # }
470 0002970B # } /* end of compare error */
471 0002970B L272:
472 0002970B # } while( index++ < max_lnf_1_index );
473 0002970B L268:
474 0002970B L265:
475 0002970B 0d effffffc97 50 movl _index,r0
476 00029712 6d effffffc90 incl _index
477 00029718 1d 50 effffffc89 cmpl r0,_max_lnf_1_index
478 0002971F 81 03 13 ff21 jlss L266
479 00029724 L264:
480 00029724 # } /* end of subtest 3 */
481 00029724 40 ret#2
482 00029725 .set L260,0x0
483 00029725 L262:
484 00029725 13 ff11 jbr L263
485 00029728 .data
486 00000d0c * .text
487 00029728 .align 1
488 00029728 .globl _pipe5_4
489 00029728 _pipe5_4:
490 00029728 0000 .word L273
491 0002972A #
492 0002972A #
493 0002972A #
494 0002972A #
495 0002972A #
496 0002972A #
497 0002972A # /************************************************************************
498 0002972A # *
499 0002972A # * SUBTEST 4
500 0002972A # * data in registers, 3 NO-OPs
501 0002972A # *
502 0002972A # ************************************************************************/
503 0002972A # pipe5_4()
504 0002972A # {
505 0002972A 13 00f0 jbr L275
506 0002972D L276:
507 0002972D # force_loop = FALSE; /* clear force_loop flag */
508 0002972D 4d effffffc75 clrl _force_loop
509 00029733 # index = 0;
510 00029733 4d effffffc6f clrl _index
511 00029739 # do
512 00029739 L279:
513 00029739 # {
514 00029739 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
515 00029739 0d effffffc69 50 movl _index,r0
516 00029740 48 03 50 50 shll $3,r0,r0
517 00029744 0d e000000000 effffffc59 movl _lnf_1_data(r0),_sgl_value_1
518 0002974F # sgl_expected = lnf_1_data[index].exp; /* get expected results */
519 0002974F 0d effffffc53 50 movl _index,r0
520 00029756 48 03 50 50 shll $3,r0,r0
521 0002975A 0d e000000004 effffffc43 movl _lnf_1_data+4(r0),_sgl_expected
522 00029765 # sgl_value_2 = 0x00000000; /* floating '0' */
523 00029765 4d effffffc3d clrl _sgl_value_2
524 0002976B # /*
525 0002976B # * If LOOP ON ERROR is set, this is the loop for this subtest.
526 0002976B # * The force loop flag is set after the first error.
527 0002976B # */
528 0002976B # asm("_pipe5_4_lp1:");
529 0002976B _pipe5_4_lp1:
530 0002976B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
531 0002976B 0d effffffc37 54 movl _sgl_value_1,r4
532 00029772 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
533 00029772 0d effffffc30 55 movl _sgl_value_2,r5
534 00029779 # asm("lnf r4"); /* load the operand */
535 00029779 16 54 lnf r4
536 0002977B # asm("nop");
537 0002977B 10 nop
538 0002977C # asm("nop");
539 0002977C 10 nop
540 0002977D # asm("nop");
541 0002977D 10 nop
542 0002977E # asm("stf r7"); /* store the result */
543 0002977E 26 57 stf r7
544 00029780 # asm("nop");
545 00029780 10 nop
546 00029781 # asm("nop");
547 00029781 10 nop
548 00029782 # asm("nop");
549 00029782 10 nop
550 00029783 # asm("lnf r5"); /* load a floating '0' */
551 00029783 16 55 lnf r5
552 00029785 # asm("nop");
553 00029785 10 nop
554 00029786 # asm("nop");
555 00029786 10 nop
556 00029787 # asm("nop");
557 00029787 10 nop
558 00029788 # asm("subf r4"); /* subtract the operand */
559 00029788 d6 54 subf r4
560 0002978A # asm("nop");
561 0002978A 10 nop
562 0002978B # asm("nop");
563 0002978B 10 nop
564 0002978C # asm("nop");
565 0002978C 10 nop
566 0002978D # asm("stf r8"); /* store the result */
567 0002978D 26 58 stf r8
568 0002978F # if( force_loop )
569 0002978F 5d effffffc13 tstl _force_loop
570 00029795 31 02 jeql L280
571 00029797 # asm("brb _pipe5_4_lp1");; /* loop on the error */
572 00029797 11 d2 brb _pipe5_4_lp1
573 00029799 L280:
574 00029799 # /*
575 00029799 # * verify the results
576 00029799 # */
577 00029799 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
578 00029799 0d 57 effffffc08 movl r7,_sgl_st_acc
579 000297A0 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
580 000297A0 0d 58 effffffc01 movl r8,_sgl_value_6
581 000297A7 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
582 000297A7 # (sgl_value_6 != sgl_expected) )
583 000297A7 1d effffffbfb effffffbf6 cmpl _sgl_st_acc,_sgl_expected
584 000297B2 21 0d jneq L9996
585 000297B4 1d effffffbee effffffbe9 cmpl _sgl_value_6,_sgl_expected
586 000297BF 31 42 jeql L281
587 000297C1 L9996:
588 000297C1 # {
589 000297C1 # errcnt++; /* bump the error count */
590 000297C1 6d effffffbe1 incl _errcnt
591 000297C7 # if ( prt_error )
592 000297C7 5d effffffbdb tstl _prt_error
593 000297CD 31 0d jeql L282
594 000297CF # print_pipe5_er("Reg. Data, 3 NO-OPs");
595 000297CF .data 1
596 00000d51 * L283:
597 00000d51 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
04E4F2D4F507300
598 00000d65 * .text
599 000297CF dd 8f00000d51 pushl $L283
600 000297D5 fe 08 ef0000073c callf $8,_print_pipe5_er
601 000297DC # if ( halt_flg )
602 000297DC L282:
603 000297DC 5d effffffbc6 tstl _halt_flg
604 000297E2 31 0d jeql L284
605 000297E4 # pipe5_er_hlt( subtest );
606 000297E4 dd effffffbbe pushl _subtest
607 000297EA fe 08 ef0000084d callf $8,_pipe5_er_hlt
608 000297F1 # if ( loop_on_err ) {
609 000297F1 L284:
610 000297F1 5d effffffbb1 tstl _loop_on_err
611 000297F7 31 0a jeql L285
612 000297F9 # force_loop = TRUE; /* set the force loop flag */
613 000297F9 0d 01 effffffba8 movl $1,_force_loop
614 00029800 # asm("brw _pipe5_4_lp1"); /* and loop */
615 00029800 13 ff68 brw _pipe5_4_lp1
616 00029803 # }
617 00029803 # } /* end of compare error */
618 00029803 L285:
619 00029803 # } while( index++ < max_lnf_1_index );
620 00029803 L281:
621 00029803 L278:
622 00029803 0d effffffb9f 50 movl _index,r0
623 0002980A 6d effffffb98 incl _index
624 00029810 1d 50 effffffb91 cmpl r0,_max_lnf_1_index
625 00029817 81 03 13 ff1d jlss L279
626 0002981C L277:
627 0002981C # } /* end of subtest 4 */
628 0002981C 40 ret#2
629 0002981D .set L273,0x0
630 0002981D L275:
631 0002981D 13 ff0d jbr L276
632 00029820 .data
633 00000d0c * .text
634 00029820 .align 1
635 00029820 .globl _pipe5_5
636 00029820 _pipe5_5:
637 00029820 0000 .word L286
638 00029822 #
639 00029822 #
640 00029822 #
641 00029822 #
642 00029822 #
643 00029822 #
644 00029822 #
645 00029822 # /************************************************************************
646 00029822 # *
647 00029822 # * SUBTEST 5
648 00029822 # * data in Cache, no NO-OPs
649 00029822 # *
650 00029822 # ************************************************************************/
651 00029822 # pipe5_5()
652 00029822 # {
653 00029822 13 00dc jbr L288
654 00029825 L289:
655 00029825 # force_loop = FALSE; /* clear force_loop flag */
656 00029825 4d effffffb7d clrl _force_loop
657 0002982B # index = 0;
658 0002982B 4d effffffb77 clrl _index
659 00029831 # do
660 00029831 L292:
661 00029831 # {
662 00029831 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
663 00029831 0d effffffb71 50 movl _index,r0
664 00029838 48 03 50 50 shll $3,r0,r0
665 0002983C 0d e000000000 effffffb61 movl _lnf_1_data(r0),_sgl_value_1
666 00029847 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
667 00029847 0d effffffb5b 50 movl _index,r0
668 0002984E 48 03 50 50 shll $3,r0,r0
669 00029852 0d e000000004 effffffb4b movl _lnf_1_data+4(r0),_sgl_expected
670 0002985D # sgl_value_2 = 0x00000000; /* floating '0' */
671 0002985D 4d effffffb45 clrl _sgl_value_2
672 00029863 # /*
673 00029863 # * If LOOP ON ERROR is set, this is the loop for this subtest.
674 00029863 # * The force loop flag is set after the first error.
675 00029863 # */
676 00029863 # asm("_pipe5_5_lp1:");
677 00029863 _pipe5_5_lp1:
678 00029863 # asm("lnf _sgl_value_1"); /* load the operand */
679 00029863 16 effffffb3f lnf _sgl_value_1
680 00029869 # asm("stf _sgl_st_acc"); /* store the result */
681 00029869 26 effffffb39 stf _sgl_st_acc
682 0002986F # asm("lnf _sgl_value_2"); /* load a floating '0' */
683 0002986F 16 effffffb33 lnf _sgl_value_2
684 00029875 # asm("subf _sgl_value_1"); /* subtract the operand */
685 00029875 d6 effffffb2d subf _sgl_value_1
686 0002987B # asm("stf _sgl_value_6"); /* store the result */
687 0002987B 26 effffffb27 stf _sgl_value_6
688 00029881 # if( force_loop )
689 00029881 5d effffffb21 tstl _force_loop
690 00029887 31 02 jeql L293
691 00029889 # asm("brb _pipe5_5_lp1");; /* loop on the error */
692 00029889 11 d8 brb _pipe5_5_lp1
693 0002988B L293:
694 0002988B # /*
695 0002988B # * verify the results
696 0002988B # */
697 0002988B # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
698 0002988B # (sgl_value_6 != sgl_expected) )
699 0002988B 1d effffffb17 effffffb12 cmpl _sgl_st_acc,_sgl_expected
700 00029896 21 0d jneq L9995
701 00029898 1d effffffb0a effffffb05 cmpl _sgl_value_6,_sgl_expected
702 000298A3 31 42 jeql L294
703 000298A5 L9995:
704 000298A5 # {
705 000298A5 # errcnt++; /* bump the error count */
706 000298A5 6d effffffafd incl _errcnt
707 000298AB # if ( prt_error )
708 000298AB 5d effffffaf7 tstl _prt_error
709 000298B1 31 0d jeql L295
710 000298B3 # print_pipe5_er("Cache Data, no NO-OPs");
711 000298B3 .data 1
712 00000d65 * L296:
713 00000d65 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
E6F204E4F2D4F507300
714 00000d7b * .text
715 000298B3 dd 8f00000d65 pushl $L296
716 000298B9 fe 08 ef00000658 callf $8,_print_pipe5_er
717 000298C0 # if ( halt_flg )
718 000298C0 L295:
719 000298C0 5d effffffae2 tstl _halt_flg
720 000298C6 31 0d jeql L297
721 000298C8 # pipe5_er_hlt( subtest );
722 000298C8 dd effffffada pushl _subtest
723 000298CE fe 08 ef00000769 callf $8,_pipe5_er_hlt
724 000298D5 # if ( loop_on_err ) {
725 000298D5 L297:
726 000298D5 5d effffffacd tstl _loop_on_err
727 000298DB 31 0a jeql L298
728 000298DD # force_loop = TRUE; /* set the force loop flag */
729 000298DD 0d 01 effffffac4 movl $1,_force_loop
730 000298E4 # asm("brw _pipe5_5_lp1"); /* and loop */
731 000298E4 13 ff7c brw _pipe5_5_lp1
732 000298E7 # }
733 000298E7 # } /* end of compare error */
734 000298E7 L298:
735 000298E7 # } while( index++ < max_lnf_1_index );
736 000298E7 L294:
737 000298E7 L291:
738 000298E7 0d effffffabb 50 movl _index,r0
739 000298EE 6d effffffab4 incl _index
740 000298F4 1d 50 effffffaad cmpl r0,_max_lnf_1_index
741 000298FB 81 03 13 ff31 jlss L292
742 00029900 L290:
743 00029900 # } /* end of subtest 5 */
744 00029900 40 ret#2
745 00029901 .set L286,0x0
746 00029901 L288:
747 00029901 13 ff21 jbr L289
748 00029904 .data
749 00000d0c * .text
750 00029904 .align 1
751 00029904 .globl _pipe5_6
752 00029904 _pipe5_6:
753 00029904 0000 .word L299
754 00029906 #
755 00029906 #
756 00029906 #
757 00029906 #
758 00029906 #
759 00029906 #
760 00029906 # /************************************************************************
761 00029906 # *
762 00029906 # * SUBTEST 6
763 00029906 # * data in Cache, 1 NO-OP
764 00029906 # *
765 00029906 # ************************************************************************/
766 00029906 # pipe5_6()
767 00029906 # {
768 00029906 13 00e0 jbr L301
769 00029909 L302:
770 00029909 # force_loop = FALSE; /* clear force_loop flag */
771 00029909 4d effffffa99 clrl _force_loop
772 0002990F # index = 0;
773 0002990F 4d effffffa93 clrl _index
774 00029915 # do
775 00029915 L305:
776 00029915 # {
777 00029915 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
778 00029915 0d effffffa8d 50 movl _index,r0
779 0002991C 48 03 50 50 shll $3,r0,r0
780 00029920 0d e000000000 effffffa7d movl _lnf_1_data(r0),_sgl_value_1
781 0002992B # sgl_expected = lnf_1_data[index].exp; /* get expected results */
782 0002992B 0d effffffa77 50 movl _index,r0
783 00029932 48 03 50 50 shll $3,r0,r0
784 00029936 0d e000000004 effffffa67 movl _lnf_1_data+4(r0),_sgl_expected
785 00029941 # sgl_value_2 = 0x00000000; /* floating '0' */
786 00029941 4d effffffa61 clrl _sgl_value_2
787 00029947 # /*
788 00029947 # * If LOOP ON ERROR is set, this is the loop for this subtest.
789 00029947 # * The force loop flag is set after the first error.
790 00029947 # */
791 00029947 # asm("_pipe5_6_lp1:");
792 00029947 _pipe5_6_lp1:
793 00029947 # asm("lnf _sgl_value_1"); /* load the operand */
794 00029947 16 effffffa5b lnf _sgl_value_1
795 0002994D # asm("nop");
796 0002994D 10 nop
797 0002994E # asm("stf _sgl_st_acc"); /* store the result */
798 0002994E 26 effffffa54 stf _sgl_st_acc
799 00029954 # asm("nop");
800 00029954 10 nop
801 00029955 # asm("lnf _sgl_value_2"); /* load a floating '0' */
802 00029955 16 effffffa4d lnf _sgl_value_2
803 0002995B # asm("nop");
804 0002995B 10 nop
805 0002995C # asm("subf _sgl_value_1"); /* subtract the operand */
806 0002995C d6 effffffa46 subf _sgl_value_1
807 00029962 # asm("nop");
808 00029962 10 nop
809 00029963 # asm("stf _sgl_value_6"); /* store the result */
810 00029963 26 effffffa3f stf _sgl_value_6
811 00029969 # if( force_loop )
812 00029969 5d effffffa39 tstl _force_loop
813 0002996F 31 02 jeql L306
814 00029971 # asm("brb _pipe5_6_lp1");; /* loop on the error */
815 00029971 11 d4 brb _pipe5_6_lp1
816 00029973 L306:
817 00029973 # /*
818 00029973 # * verify the results
819 00029973 # */
820 00029973 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
821 00029973 # (sgl_value_6 != sgl_expected) )
822 00029973 1d effffffa2f effffffa2a cmpl _sgl_st_acc,_sgl_expected
823 0002997E 21 0d jneq L9994
824 00029980 1d effffffa22 effffffa1d cmpl _sgl_value_6,_sgl_expected
825 0002998B 31 42 jeql L307
826 0002998D L9994:
827 0002998D # {
828 0002998D # errcnt++; /* bump the error count */
829 0002998D 6d effffffa15 incl _errcnt
830 00029993 # if ( prt_error )
831 00029993 5d effffffa0f tstl _prt_error
832 00029999 31 0d jeql L308
833 0002999B # print_pipe5_er("Cache Data, 1 NO-OP");
834 0002999B .data 1
835 00000d7b * L309:
836 00000d7b * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
837 00000d8f * .text
838 0002999B dd 8f00000d7b pushl $L309
839 000299A1 fe 08 ef00000570 callf $8,_print_pipe5_er
840 000299A8 # if ( halt_flg )
841 000299A8 L308:
842 000299A8 5d effffff9fa tstl _halt_flg
843 000299AE 31 0d jeql L310
844 000299B0 # pipe5_er_hlt( subtest );
845 000299B0 dd effffff9f2 pushl _subtest
846 000299B6 fe 08 ef00000681 callf $8,_pipe5_er_hlt
847 000299BD # if ( loop_on_err ) {
848 000299BD L310:
849 000299BD 5d effffff9e5 tstl _loop_on_err
850 000299C3 31 0a jeql L311
851 000299C5 # force_loop = TRUE; /* set the force loop flag */
852 000299C5 0d 01 effffff9dc movl $1,_force_loop
853 000299CC # asm("brw _pipe5_6_lp1"); /* and loop */
854 000299CC 13 ff78 brw _pipe5_6_lp1
855 000299CF # }
856 000299CF # } /* end of compare error */
857 000299CF L311:
858 000299CF # } while( index++ < max_lnf_1_index );
859 000299CF L307:
860 000299CF L304:
861 000299CF 0d effffff9d3 50 movl _index,r0
862 000299D6 6d effffff9cc incl _index
863 000299DC 1d 50 effffff9c5 cmpl r0,_max_lnf_1_index
864 000299E3 81 03 13 ff2d jlss L305
865 000299E8 L303:
866 000299E8 # } /* end of subtest 6 */
867 000299E8 40 ret#2
868 000299E9 .set L299,0x0
869 000299E9 L301:
870 000299E9 13 ff1d jbr L302
871 000299EC .data
872 00000d0c * .text
873 000299EC .align 1
874 000299EC .globl _pipe5_7
875 000299EC _pipe5_7:
876 000299EC 0000 .word L312
877 000299EE #
878 000299EE #
879 000299EE #
880 000299EE #
881 000299EE #
882 000299EE #
883 000299EE # /************************************************************************
884 000299EE # *
885 000299EE # * SUBTEST 7
886 000299EE # * data in Cache, 2 NO-OPs
887 000299EE # *
888 000299EE # ************************************************************************/
889 000299EE # pipe5_7()
890 000299EE # {
891 000299EE 13 00e4 jbr L314
892 000299F1 L315:
893 000299F1 # force_loop = FALSE; /* clear force_loop flag */
894 000299F1 4d effffff9b1 clrl _force_loop
895 000299F7 # index = 0;
896 000299F7 4d effffff9ab clrl _index
897 000299FD # do
898 000299FD L318:
899 000299FD # {
900 000299FD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
901 000299FD 0d effffff9a5 50 movl _index,r0
902 00029A04 48 03 50 50 shll $3,r0,r0
903 00029A08 0d e000000000 effffff995 movl _lnf_1_data(r0),_sgl_value_1
904 00029A13 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
905 00029A13 0d effffff98f 50 movl _index,r0
906 00029A1A 48 03 50 50 shll $3,r0,r0
907 00029A1E 0d e000000004 effffff97f movl _lnf_1_data+4(r0),_sgl_expected
908 00029A29 # sgl_value_2 = 0x00000000; /* floating '0' */
909 00029A29 4d effffff979 clrl _sgl_value_2
910 00029A2F # /*
911 00029A2F # * If LOOP ON ERROR is set, this is the loop for this subtest.
912 00029A2F # * The force loop flag is set after the first error.
913 00029A2F # */
914 00029A2F # asm("_pipe5_7_lp1:");
915 00029A2F _pipe5_7_lp1:
916 00029A2F # asm("lnf _sgl_value_1"); /* load the operand */
917 00029A2F 16 effffff973 lnf _sgl_value_1
918 00029A35 # asm("nop");
919 00029A35 10 nop
920 00029A36 # asm("nop");
921 00029A36 10 nop
922 00029A37 # asm("stf _sgl_st_acc"); /* store the result */
923 00029A37 26 effffff96b stf _sgl_st_acc
924 00029A3D # asm("nop");
925 00029A3D 10 nop
926 00029A3E # asm("nop");
927 00029A3E 10 nop
928 00029A3F # asm("lnf _sgl_value_2"); /* load a floating '0' */
929 00029A3F 16 effffff963 lnf _sgl_value_2
930 00029A45 # asm("nop");
931 00029A45 10 nop
932 00029A46 # asm("nop");
933 00029A46 10 nop
934 00029A47 # asm("subf _sgl_value_1"); /* subtract the operand */
935 00029A47 d6 effffff95b subf _sgl_value_1
936 00029A4D # asm("nop");
937 00029A4D 10 nop
938 00029A4E # asm("nop");
939 00029A4E 10 nop
940 00029A4F # asm("stf _sgl_value_6"); /* store the result */
941 00029A4F 26 effffff953 stf _sgl_value_6
942 00029A55 # if( force_loop )
943 00029A55 5d effffff94d tstl _force_loop
944 00029A5B 31 02 jeql L319
945 00029A5D # asm("brb _pipe5_7_lp1");; /* loop on the error */
946 00029A5D 11 d0 brb _pipe5_7_lp1
947 00029A5F L319:
948 00029A5F # /*
949 00029A5F # * verify the results
950 00029A5F # */
951 00029A5F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
952 00029A5F # (sgl_value_6 != sgl_expected) )
953 00029A5F 1d effffff943 effffff93e cmpl _sgl_st_acc,_sgl_expected
954 00029A6A 21 0d jneq L9993
955 00029A6C 1d effffff936 effffff931 cmpl _sgl_value_6,_sgl_expected
956 00029A77 31 42 jeql L320
957 00029A79 L9993:
958 00029A79 # {
959 00029A79 # errcnt++; /* bump the error count */
960 00029A79 6d effffff929 incl _errcnt
961 00029A7F # if ( prt_error )
962 00029A7F 5d effffff923 tstl _prt_error
963 00029A85 31 0d jeql L321
964 00029A87 # print_pipe5_er("Cache Data, 2 NO-OPs");
965 00029A87 .data 1
966 00000d8f * L322:
967 00000d8f * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
2204E4F2D4F507300
968 00000da4 * .text
969 00029A87 dd 8f00000d8f pushl $L322
970 00029A8D fe 08 ef00000484 callf $8,_print_pipe5_er
971 00029A94 # if ( halt_flg )
972 00029A94 L321:
973 00029A94 5d effffff90e tstl _halt_flg
974 00029A9A 31 0d jeql L323
975 00029A9C # pipe5_er_hlt( subtest );
976 00029A9C dd effffff906 pushl _subtest
977 00029AA2 fe 08 ef00000595 callf $8,_pipe5_er_hlt
978 00029AA9 # if ( loop_on_err ) {
979 00029AA9 L323:
980 00029AA9 5d effffff8f9 tstl _loop_on_err
981 00029AAF 31 0a jeql L324
982 00029AB1 # force_loop = TRUE; /* set the force loop flag */
983 00029AB1 0d 01 effffff8f0 movl $1,_force_loop
984 00029AB8 # asm("brw _pipe5_7_lp1"); /* and loop */
985 00029AB8 13 ff74 brw _pipe5_7_lp1
986 00029ABB # }
987 00029ABB # } /* end of compare error */
988 00029ABB L324:
989 00029ABB # } while( index++ < max_lnf_1_index );
990 00029ABB L320:
991 00029ABB L317:
992 00029ABB 0d effffff8e7 50 movl _index,r0
993 00029AC2 6d effffff8e0 incl _index
994 00029AC8 1d 50 effffff8d9 cmpl r0,_max_lnf_1_index
995 00029ACF 81 03 13 ff29 jlss L318
996 00029AD4 L316:
997 00029AD4 # } /* end of subtest 7 */
998 00029AD4 40 ret#2
999 00029AD5 .set L312,0x0
1000 00029AD5 L314:
1001 00029AD5 13 ff19 jbr L315
1002 00029AD8 .data
1003 00000d0c * .text
1004 00029AD8 .align 1
1005 00029AD8 .globl _pipe5_8
1006 00029AD8 _pipe5_8:
1007 00029AD8 0000 .word L325
1008 00029ADA #
1009 00029ADA #
1010 00029ADA #
1011 00029ADA #
1012 00029ADA #
1013 00029ADA #
1014 00029ADA # /************************************************************************
1015 00029ADA # *
1016 00029ADA # * SUBTEST 8
1017 00029ADA # * data in Cache, 3 NO-OPs
1018 00029ADA # *
1019 00029ADA # ************************************************************************/
1020 00029ADA # pipe5_8()
1021 00029ADA # {
1022 00029ADA 13 00e8 jbr L327
1023 00029ADD L328:
1024 00029ADD # force_loop = FALSE; /* clear force_loop flag */
1025 00029ADD 4d effffff8c5 clrl _force_loop
1026 00029AE3 # index = 0;
1027 00029AE3 4d effffff8bf clrl _index
1028 00029AE9 # do
1029 00029AE9 L331:
1030 00029AE9 # {
1031 00029AE9 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1032 00029AE9 0d effffff8b9 50 movl _index,r0
1033 00029AF0 48 03 50 50 shll $3,r0,r0
1034 00029AF4 0d e000000000 effffff8a9 movl _lnf_1_data(r0),_sgl_value_1
1035 00029AFF # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1036 00029AFF 0d effffff8a3 50 movl _index,r0
1037 00029B06 48 03 50 50 shll $3,r0,r0
1038 00029B0A 0d e000000004 effffff893 movl _lnf_1_data+4(r0),_sgl_expected
1039 00029B15 # sgl_value_2 = 0x00000000; /* floating '0' */
1040 00029B15 4d effffff88d clrl _sgl_value_2
1041 00029B1B # /*
1042 00029B1B # * If LOOP ON ERROR is set, this is the loop for this subtest.
1043 00029B1B # * The force loop flag is set after the first error.
1044 00029B1B # */
1045 00029B1B # asm("_pipe5_8_lp1:");
1046 00029B1B _pipe5_8_lp1:
1047 00029B1B # asm("lnf _sgl_value_1"); /* load the operand */
1048 00029B1B 16 effffff887 lnf _sgl_value_1
1049 00029B21 # asm("nop");
1050 00029B21 10 nop
1051 00029B22 # asm("nop");
1052 00029B22 10 nop
1053 00029B23 # asm("nop");
1054 00029B23 10 nop
1055 00029B24 # asm("stf _sgl_st_acc"); /* store the result */
1056 00029B24 26 effffff87e stf _sgl_st_acc
1057 00029B2A # asm("nop");
1058 00029B2A 10 nop
1059 00029B2B # asm("nop");
1060 00029B2B 10 nop
1061 00029B2C # asm("nop");
1062 00029B2C 10 nop
1063 00029B2D # asm("lnf _sgl_value_2"); /* load a floating '0' */
1064 00029B2D 16 effffff875 lnf _sgl_value_2
1065 00029B33 # asm("nop");
1066 00029B33 10 nop
1067 00029B34 # asm("nop");
1068 00029B34 10 nop
1069 00029B35 # asm("nop");
1070 00029B35 10 nop
1071 00029B36 # asm("subf _sgl_value_1"); /* subtract the operand */
1072 00029B36 d6 effffff86c subf _sgl_value_1
1073 00029B3C # asm("nop");
1074 00029B3C 10 nop
1075 00029B3D # asm("nop");
1076 00029B3D 10 nop
1077 00029B3E # asm("nop");
1078 00029B3E 10 nop
1079 00029B3F # asm("stf _sgl_value_6"); /* store the result */
1080 00029B3F 26 effffff863 stf _sgl_value_6
1081 00029B45 # if( force_loop )
1082 00029B45 5d effffff85d tstl _force_loop
1083 00029B4B 31 02 jeql L332
1084 00029B4D # asm("brb _pipe5_8_lp1");; /* loop on the error */
1085 00029B4D 11 cc brb _pipe5_8_lp1
1086 00029B4F L332:
1087 00029B4F # /*
1088 00029B4F # * verify the results
1089 00029B4F # */
1090 00029B4F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1091 00029B4F # (sgl_value_6 != sgl_expected) )
1092 00029B4F 1d effffff853 effffff84e cmpl _sgl_st_acc,_sgl_expected
1093 00029B5A 21 0d jneq L9992
1094 00029B5C 1d effffff846 effffff841 cmpl _sgl_value_6,_sgl_expected
1095 00029B67 31 42 jeql L333
1096 00029B69 L9992:
1097 00029B69 # {
1098 00029B69 # errcnt++; /* bump the error count */
1099 00029B69 6d effffff839 incl _errcnt
1100 00029B6F # if ( prt_error )
1101 00029B6F 5d effffff833 tstl _prt_error
1102 00029B75 31 0d jeql L334
1103 00029B77 # print_pipe5_er("Cache Data, 3 NO-OPs");
1104 00029B77 .data 1
1105 00000da4 * L335:
1106 00000da4 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
3204E4F2D4F507300
1107 00000db9 * .text
1108 00029B77 dd 8f00000da4 pushl $L335
1109 00029B7D fe 08 ef00000394 callf $8,_print_pipe5_er
1110 00029B84 # if ( halt_flg )
1111 00029B84 L334:
1112 00029B84 5d effffff81e tstl _halt_flg
1113 00029B8A 31 0d jeql L336
1114 00029B8C # pipe5_er_hlt( subtest );
1115 00029B8C dd effffff816 pushl _subtest
1116 00029B92 fe 08 ef000004a5 callf $8,_pipe5_er_hlt
1117 00029B99 # if ( loop_on_err ) {
1118 00029B99 L336:
1119 00029B99 5d effffff809 tstl _loop_on_err
1120 00029B9F 31 0a jeql L337
1121 00029BA1 # force_loop = TRUE; /* set the force loop flag */
1122 00029BA1 0d 01 effffff800 movl $1,_force_loop
1123 00029BA8 # asm("brw _pipe5_8_lp1"); /* and loop */
1124 00029BA8 13 ff70 brw _pipe5_8_lp1
1125 00029BAB # }
1126 00029BAB # } /* end of compare error */
1127 00029BAB L337:
1128 00029BAB # } while( index++ < max_lnf_1_index );
1129 00029BAB L333:
1130 00029BAB L330:
1131 00029BAB 0d effffff7f7 50 movl _index,r0
1132 00029BB2 6d effffff7f0 incl _index
1133 00029BB8 1d 50 effffff7e9 cmpl r0,_max_lnf_1_index
1134 00029BBF 81 03 13 ff25 jlss L331
1135 00029BC4 L329:
1136 00029BC4 # } /* end of subtest 8 */
1137 00029BC4 40 ret#2
1138 00029BC5 .set L325,0x0
1139 00029BC5 L327:
1140 00029BC5 13 ff15 jbr L328
1141 00029BC8 .data
1142 00000d0c * .text
1143 00029BC8 .align 1
1144 00029BC8 .globl _pipe5_9
1145 00029BC8 _pipe5_9:
1146 00029BC8 0000 .word L338
1147 00029BCA #
1148 00029BCA #
1149 00029BCA #
1150 00029BCA #
1151 00029BCA #
1152 00029BCA #
1153 00029BCA # /*****************************************************************************
1154 00029BCA # *
1155 00029BCA # * SUBTEST 9
1156 00029BCA # * data on the stack, no NO-OPs
1157 00029BCA # *
1158 00029BCA # *****************************************************************************/
1159 00029BCA # pipe5_9()
1160 00029BCA # {
1161 00029BCA 13 017f jbr L340
1162 00029BCD L341:
1163 00029BCD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1164 00029BCD ed 6d effffff7d4 moval (r13),_pre_event_fp
1165 00029BD4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1166 00029BD4 ed 6e effffff7cd moval (r14),_pre_event_sp
1167 00029BDB # force_loop = FALSE; /* clear force_loop flag */
1168 00029BDB 4d effffff7c7 clrl _force_loop
1169 00029BE1 # index = 0;
1170 00029BE1 4d effffff7c1 clrl _index
1171 00029BE7 # do
1172 00029BE7 L344:
1173 00029BE7 # {
1174 00029BE7 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1175 00029BE7 0d effffff7bb 50 movl _index,r0
1176 00029BEE 48 03 50 50 shll $3,r0,r0
1177 00029BF2 0d e000000000 effffff7ab movl _lnf_1_data(r0),_sgl_value_1
1178 00029BFD # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1179 00029BFD 0d effffff7a5 50 movl _index,r0
1180 00029C04 48 03 50 50 shll $3,r0,r0
1181 00029C08 0d e000000004 effffff795 movl _lnf_1_data+4(r0),_sgl_expected
1182 00029C13 # sgl_value_2 = 0x00000000; /* floating '0' */
1183 00029C13 4d effffff78f clrl _sgl_value_2
1184 00029C19 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1185 00029C19 ed effffff789 effffff784 moval _pointer_data,_sgl_value_4
1186 00029C24 # /*
1187 00029C24 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1188 00029C24 # * The force loop flag is set after the first error.
1189 00029C24 # */
1190 00029C24 # asm("_pipe5_9_lp1:");
1191 00029C24 _pipe5_9_lp1:
1192 00029C24 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1193 00029C24 ed effffff77e 5e moval _pointer_data,r14
1194 00029C2B # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1195 00029C2B 0d effffff777 7e movl _sgl_value_1,-(r14)
1196 00029C32 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */
1197 00029C32 0d effffff770 7e movl _sgl_value_2,-(r14)
1198 00029C39 # asm("movl _sgl_value_1,-(r14)"); /* push the operand again */
1199 00029C39 0d effffff769 7e movl _sgl_value_1,-(r14)
1200 00029C40 # /*
1201 00029C40 # * now pop the data off the stack
1202 00029C40 # */
1203 00029C40 #
1204 00029C40 # asm("lnf (r14)+"); /* load the operand */
1205 00029C40 16 8e lnf (r14)+
1206 00029C42 # asm("stf r5"); /* store the result */
1207 00029C42 26 55 stf r5
1208 00029C44 # asm("lnf (r14)+"); /* load a floating '0' */
1209 00029C44 16 8e lnf (r14)+
1210 00029C46 # asm("subf (r14)+"); /* subtract the operand */
1211 00029C46 d6 8e subf (r14)+
1212 00029C48 # asm("stf r6"); /* store the result */
1213 00029C48 26 56 stf r6
1214 00029C4A # if( force_loop )
1215 00029C4A 5d effffff758 tstl _force_loop
1216 00029C50 31 02 jeql L345
1217 00029C52 # asm("brb _pipe5_9_lp1");; /* loop on the error */
1218 00029C52 11 d0 brb _pipe5_9_lp1
1219 00029C54 L345:
1220 00029C54 # /*
1221 00029C54 # * verify the results
1222 00029C54 # */
1223 00029C54 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1224 00029C54 0d 55 effffff74d movl r5,_sgl_st_acc
1225 00029C5B # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1226 00029C5B 0d 56 effffff746 movl r6,_sgl_value_6
1227 00029C62 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1228 00029C62 ed 6e effffff73f moval (r14),_sgl_value_5
1229 00029C69 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1230 00029C69 # (sgl_value_6 != sgl_expected) ||
1231 00029C69 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1232 00029C69 1d effffff739 effffff734 cmpl _sgl_st_acc,_sgl_expected
1233 00029C74 21 1d jneq L9991
1234 00029C76 1d effffff72c effffff727 cmpl _sgl_value_6,_sgl_expected
1235 00029C81 21 10 jneq L9991
1236 00029C83 1d effffff71f effffff71a cmpl _sgl_value_5,_sgl_value_4
1237 00029C8E 21 03 13 0091 jeql L346
1238 00029C93 L9991:
1239 00029C93 # {
1240 00029C93 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1241 00029C93 0d effffff70f 5d movl _pre_event_fp,r13
1242 00029C9A # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1243 00029C9A 0d effffff708 5e movl _pre_event_sp,r14
1244 00029CA1 # errcnt++; /* bump the error count */
1245 00029CA1 6d effffff701 incl _errcnt
1246 00029CA7 # if ( prt_error ) {
1247 00029CA7 5d effffff6fb tstl _prt_error
1248 00029CAD 31 4e jeql L347
1249 00029CAF # print_pipe5_er("POP data from the STACK");
1250 00029CAF .data 1
1251 00000db9 * L348:
1252 00000db9 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
D2074686520535441434B00
1253 00000dd1 * .text
1254 00029CAF dd 8f00000db9 pushl $L348
1255 00029CB5 fe 08 ef0000025c callf $8,_print_pipe5_er
1256 00029CBC # writes("final Stack Pointer = ");
1257 00029CBC .data 1
1258 00000dd1 * L349:
1259 00000dd1 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1260 00000de8 * .text
1261 00029CBC dd 8f00000dd1 pushl $L349
1262 00029CC2 fe 08 effffff6df callf $8,_writes
1263 00029CC9 # write32h( sgl_value_5 );
1264 00029CC9 dd effffff6d9 pushl _sgl_value_5
1265 00029CCF fe 08 effffff6d2 callf $8,_write32h
1266 00029CD6 # writes(", expected SP = ");
1267 00029CD6 .data 1
1268 00000de8 * L351:
1269 00000de8 * 2C20206578706563746564205 .ascii ", expected SP = \0"
350203D2000
1270 00000dfa * .text
1271 00029CD6 dd 8f00000de8 pushl $L351
1272 00029CDC fe 08 effffff6c5 callf $8,_writes
1273 00029CE3 # write32h( sgl_value_4 );
1274 00029CE3 dd effffff6bf pushl _sgl_value_4
1275 00029CE9 fe 08 effffff6b8 callf $8,_write32h
1276 00029CF0 # writes("\n");
1277 00029CF0 .data 1
1278 00000dfa * L352:
1279 00000dfa * 0A00 .ascii "\12\0"
1280 00000dfc * .text
1281 00029CF0 dd 8f00000dfa pushl $L352
1282 00029CF6 fe 08 effffff6ab callf $8,_writes
1283 00029CFD # }
1284 00029CFD # if ( halt_flg )
1285 00029CFD L347:
1286 00029CFD 5d effffff6a5 tstl _halt_flg
1287 00029D03 31 0d jeql L353
1288 00029D05 # pipe5_er_hlt( subtest );
1289 00029D05 dd effffff69d pushl _subtest
1290 00029D0B fe 08 ef0000032c callf $8,_pipe5_er_hlt
1291 00029D12 # if ( loop_on_err ) {
1292 00029D12 L353:
1293 00029D12 5d effffff690 tstl _loop_on_err
1294 00029D18 31 0a jeql L354
1295 00029D1A # force_loop = TRUE; /* set the force loop flag */
1296 00029D1A 0d 01 effffff687 movl $1,_force_loop
1297 00029D21 # asm("brw _pipe5_9_lp1"); /* and loop */
1298 00029D21 13 ff00 brw _pipe5_9_lp1
1299 00029D24 # }
1300 00029D24 # } /* end of compare error */
1301 00029D24 L354:
1302 00029D24 # } while( index++ < max_lnf_1_index );
1303 00029D24 L346:
1304 00029D24 L343:
1305 00029D24 0d effffff67e 50 movl _index,r0
1306 00029D2B 6d effffff677 incl _index
1307 00029D31 1d 50 effffff670 cmpl r0,_max_lnf_1_index
1308 00029D38 81 03 13 feaa jlss L344
1309 00029D3D L342:
1310 00029D3D # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1311 00029D3D 0d effffff665 5d movl _pre_event_fp,r13
1312 00029D44 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1313 00029D44 0d effffff65e 5e movl _pre_event_sp,r14
1314 00029D4B # } /* end of subtest 9 */
1315 00029D4B 40 ret#2
1316 00029D4C .set L338,0x0
1317 00029D4C L340:
1318 00029D4C 13 fe7e jbr L341
1319 00029D4F .data
1320 00000d0c * .text
1321 00029D4F 00 .align 1
1322 00029D50 .globl _pipe5_10
1323 00029D50 _pipe5_10:
1324 00029D50 0000 .word L355
1325 00029D52 #
1326 00029D52 #
1327 00029D52 #
1328 00029D52 #
1329 00029D52 #
1330 00029D52 #
1331 00029D52 # /******************************************************************************
1332 00029D52 # *
1333 00029D52 # * SUBTEST 10
1334 00029D52 # * get data via indexed FRAME pointer
1335 00029D52 # *
1336 00029D52 # * ADDR INDEX DATA
1337 00029D52 # * pointer_data 4 <the 1st STF result goes here>
1338 00029D52 # * pointer_data-4 3 <the 2nd STF result goes here>
1339 00029D52 # * pointer_data-8 2 <operand data>
1340 00029D52 # * pointer_data-12 1 <floating '0'>
1341 00029D52 # * pointer_data-16 0 point the frame pointer here
1342 00029D52 # *
1343 00029D52 # ******************************************************************************/
1344 00029D52 # pipe5_10()
1345 00029D52 # {
1346 00029D52 13 01c0 jbr L357
1347 00029D55 L358:
1348 00029D55 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1349 00029D55 ed 6d effffff64c moval (r13),_pre_event_fp
1350 00029D5C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1351 00029D5C ed 6e effffff645 moval (r14),_pre_event_sp
1352 00029D63 # force_loop = FALSE; /* clear force_loop flag */
1353 00029D63 4d effffff63f clrl _force_loop
1354 00029D69 # index = 0;
1355 00029D69 4d effffff639 clrl _index
1356 00029D6F # do
1357 00029D6F L361:
1358 00029D6F # {
1359 00029D6F # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1360 00029D6F 0d effffff633 50 movl _index,r0
1361 00029D76 48 03 50 50 shll $3,r0,r0
1362 00029D7A 0d e000000000 effffff623 movl _lnf_1_data(r0),_sgl_value_1
1363 00029D85 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1364 00029D85 0d effffff61d 50 movl _index,r0
1365 00029D8C 48 03 50 50 shll $3,r0,r0
1366 00029D90 0d e000000004 effffff60d movl _lnf_1_data+4(r0),_sgl_expected
1367 00029D9B # sgl_value_2 = 0x00000000; /* floating '0' */
1368 00029D9B 4d effffff607 clrl _sgl_value_2
1369 00029DA1 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1370 00029DA1 ed effffff601 effffff5fc moval _pointer_data,_sgl_value_4
1371 00029DAC # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1372 00029DAC 2c 08 effffff5f5 subl2 $8,_sgl_value_4
1373 00029DB3 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1374 00029DB3 0d effffff5ef fffffff5ea movl _sgl_value_1,*_sgl_value_4
1375 00029DBE # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1376 00029DBE 2c 04 effffff5e3 subl2 $4,_sgl_value_4
1377 00029DC5 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '0' */
1378 00029DC5 0d effffff5dd fffffff5d8 movl _sgl_value_2,*_sgl_value_4
1379 00029DD0 # sgl_value_4 -= 4; /* get FRAME PTR address */
1380 00029DD0 2c 04 effffff5d1 subl2 $4,_sgl_value_4
1381 00029DD7 # /*
1382 00029DD7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1383 00029DD7 # * The force loop flag is set after the first error.
1384 00029DD7 # */
1385 00029DD7 # asm("_pipe5_10_lp1:");
1386 00029DD7 _pipe5_10_lp1:
1387 00029DD7 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1388 00029DD7 0d effffff5cb 5d movl _sgl_value_4,r13
1389 00029DDE # asm("movl $1,r1"); /* r1 index = 1 longwords */
1390 00029DDE 0d 01 51 movl $1,r1
1391 00029DE1 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1392 00029DE1 0d 02 52 movl $2,r2
1393 00029DE4 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1394 00029DE4 0d 03 53 movl $3,r3
1395 00029DE7 # asm("movl $4,r4"); /* r4 index = 4 longwords */
1396 00029DE7 0d 04 54 movl $4,r4
1397 00029DEA # asm("lnf (r13)[r2]"); /* load the op (indx = 2) */
1398 00029DEA 16 426d lnf (r13)[r2]
1399 00029DED # asm("stf (r13)[r4]"); /* store -index = 4 */
1400 00029DED 26 446d stf (r13)[r4]
1401 00029DF0 # asm("lnf (r13)[r1]"); /* load '0' (indx = 1) */
1402 00029DF0 16 416d lnf (r13)[r1]
1403 00029DF3 # asm("subf (r13)[r2]"); /* subtract the operand */
1404 00029DF3 d6 426d subf (r13)[r2]
1405 00029DF6 # asm("stf (r13)[r3]"); /* store -index = 3 */
1406 00029DF6 26 436d stf (r13)[r3]
1407 00029DF9 # if( force_loop )
1408 00029DF9 5d effffff5a9 tstl _force_loop
1409 00029DFF 31 02 jeql L362
1410 00029E01 # asm("brb _pipe5_10_lp1");; /* loop on the error */
1411 00029E01 11 d4 brb _pipe5_10_lp1
1412 00029E03 L362:
1413 00029E03 # /*
1414 00029E03 # * verify the results
1415 00029E03 # */
1416 00029E03 # sgl_st_acc = pointer_data; /* save 1st stored value */
1417 00029E03 0d effffff59f effffff59a movl _pointer_data,_sgl_st_acc
1418 00029E0E # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1419 00029E0E ed effffff594 effffff58f moval _pointer_data,_sgl_value_5
1420 00029E19 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1421 00029E19 2c 04 effffff588 subl2 $4,_sgl_value_5
1422 00029E20 # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1423 00029E20 0d fffffff582 effffff57d movl *_sgl_value_5,_sgl_value_6
1424 00029E2B # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1425 00029E2B ed 6d effffff576 moval (r13),_sgl_value_5
1426 00029E32 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1427 00029E32 # (sgl_value_6 != sgl_expected) ||
1428 00029E32 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1429 00029E32 1d effffff570 effffff56b cmpl _sgl_st_acc,_sgl_expected
1430 00029E3D 21 1d jneq L9990
1431 00029E3F 1d effffff563 effffff55e cmpl _sgl_value_6,_sgl_expected
1432 00029E4A 21 10 jneq L9990
1433 00029E4C 1d effffff556 effffff551 cmpl _sgl_value_5,_sgl_value_4
1434 00029E57 21 03 13 0091 jeql L363
1435 00029E5C L9990:
1436 00029E5C # {
1437 00029E5C # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1438 00029E5C 0d effffff546 5d movl _pre_event_fp,r13
1439 00029E63 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1440 00029E63 0d effffff53f 5e movl _pre_event_sp,r14
1441 00029E6A # errcnt++; /* bump the error count */
1442 00029E6A 6d effffff538 incl _errcnt
1443 00029E70 # if ( prt_error ) {
1444 00029E70 5d effffff532 tstl _prt_error
1445 00029E76 31 4e jeql L364
1446 00029E78 # print_pipe5_er("indexed FP addressing");
1447 00029E78 .data 1
1448 00000dfc * L365:
1449 00000dfc * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1450 00000e12 * .text
1451 00029E78 dd 8f00000dfc pushl $L365
1452 00029E7E fe 08 ef00000093 callf $8,_print_pipe5_er
1453 00029E85 # writes("final Frame Pointer = ");
1454 00029E85 .data 1
1455 00000e12 * L366:
1456 00000e12 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1457 00000e29 * .text
1458 00029E85 dd 8f00000e12 pushl $L366
1459 00029E8B fe 08 effffff516 callf $8,_writes
1460 00029E92 # writeh( sgl_value_5 );
1461 00029E92 dd effffff510 pushl _sgl_value_5
1462 00029E98 fe 08 effffff509 callf $8,_writeh
1463 00029E9F # writes(", expected FP = ");
1464 00029E9F .data 1
1465 00000e29 * L368:
1466 00000e29 * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1467 00000e3b * .text
1468 00029E9F dd 8f00000e29 pushl $L368
1469 00029EA5 fe 08 effffff4fc callf $8,_writes
1470 00029EAC # writeh( sgl_value_4 );
1471 00029EAC dd effffff4f6 pushl _sgl_value_4
1472 00029EB2 fe 08 effffff4ef callf $8,_writeh
1473 00029EB9 # writes("\n");
1474 00029EB9 .data 1
1475 00000e3b * L369:
1476 00000e3b * 0A00 .ascii "\12\0"
1477 00000e3d * .text
1478 00029EB9 dd 8f00000e3b pushl $L369
1479 00029EBF fe 08 effffff4e2 callf $8,_writes
1480 00029EC6 # }
1481 00029EC6 # if ( halt_flg )
1482 00029EC6 L364:
1483 00029EC6 5d effffff4dc tstl _halt_flg
1484 00029ECC 31 0d jeql L370
1485 00029ECE # pipe5_er_hlt( subtest );
1486 00029ECE dd effffff4d4 pushl _subtest
1487 00029ED4 fe 08 ef00000163 callf $8,_pipe5_er_hlt
1488 00029EDB # if ( loop_on_err ) {
1489 00029EDB L370:
1490 00029EDB 5d effffff4c7 tstl _loop_on_err
1491 00029EE1 31 0a jeql L371
1492 00029EE3 # force_loop = TRUE; /* set the force loop flag */
1493 00029EE3 0d 01 effffff4be movl $1,_force_loop
1494 00029EEA # asm("brw _pipe5_10_lp1"); /* and loop */
1495 00029EEA 13 feea brw _pipe5_10_lp1
1496 00029EED # }
1497 00029EED # } /* end of compare error */
1498 00029EED L371:
1499 00029EED # } while( index++ < max_lnf_1_index );
1500 00029EED L363:
1501 00029EED L360:
1502 00029EED 0d effffff4b5 50 movl _index,r0
1503 00029EF4 6d effffff4ae incl _index
1504 00029EFA 1d 50 effffff4a7 cmpl r0,_max_lnf_1_index
1505 00029F01 81 03 13 fe69 jlss L361
1506 00029F06 L359:
1507 00029F06 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1508 00029F06 0d effffff49c 5d movl _pre_event_fp,r13
1509 00029F0D # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1510 00029F0D 0d effffff495 5e movl _pre_event_sp,r14
1511 00029F14 # } /* end of subtest 10 */
1512 00029F14 40 ret#2
1513 00029F15 .set L355,0x0
1514 00029F15 L357:
1515 00029F15 13 fe3d jbr L358
1516 00029F18 .data
1517 00000d0c * .text
1518 00029F18 .align 1
1519 00029F18 .globl _print_pipe5_er
1520 00029F18 _print_pipe5_er:
1521 00029F18 0000 .word L372
1522 00029F1A #
1523 00029F1A #
1524 00029F1A # /******************************************************************************
1525 00029F1A # *
1526 00029F1A # *
1527 00029F1A # * print an error in the following form
1528 00029F1A # *
1529 00029F1A # * operand = xxxxxxxx, 1st store = xxxxxxxx, data index = dd
1530 00029F1A # * 2nd store = xxxxxxxx, expected Acc = xxxxxxxx
1531 00029F1A # *
1532 00029F1A # ******************************************************************************/
1533 00029F1A # print_pipe5_er(msg)
1534 00029F1A # char *msg;
1535 00029F1A # {
1536 00029F1A 13 011d jbr L374
1537 00029F1D L375:
1538 00029F1D # writes("\n"); /* start a new print line */
1539 00029F1D .data 1
1540 00000e3d * L376:
1541 00000e3d * 0A00 .ascii "\12\0"
1542 00000e3f * .text
1543 00029F1D dd 8f00000e3d pushl $L376
1544 00029F23 fe 08 effffff47e callf $8,_writes
1545 00029F2A # writes("cycle: ");
1546 00029F2A .data 1
1547 00000e3f * L377:
1548 00000e3f * 6379636C653A2000 .ascii "cycle: \0"
1549 00000e47 * .text
1550 00029F2A dd 8f00000e3f pushl $L377
1551 00029F30 fe 08 effffff471 callf $8,_writes
1552 00029F37 # writed( cycle );
1553 00029F37 dd effffff46b pushl _cycle
1554 00029F3D fe 08 effffff464 callf $8,_writed
1555 00029F44 # writes(" test ");
1556 00029F44 .data 1
1557 00000e47 * L379:
1558 00000e47 * 20746573742000 .ascii " test \0"
1559 00000e4e * .text
1560 00029F44 dd 8f00000e47 pushl $L379
1561 00029F4A fe 08 effffff457 callf $8,_writes
1562 00029F51 # writed( test_no );
1563 00029F51 dd effffff451 pushl _test_no
1564 00029F57 fe 08 effffff44a callf $8,_writed
1565 00029F5E # writes(" (Pipe 5), subtest ");
1566 00029F5E .data 1
1567 00000e4e * L380:
1568 00000e4e * 202028506970652035292C207 .ascii " (Pipe 5), subtest \0"
37562746573742000
1569 00000e63 * .text
1570 00029F5E dd 8f00000e4e pushl $L380
1571 00029F64 fe 08 effffff43d callf $8,_writes
1572 00029F6B # writed( subtest );
1573 00029F6B dd effffff437 pushl _subtest
1574 00029F71 fe 08 effffff430 callf $8,_writed
1575 00029F78 # writes(" error - ");
1576 00029F78 .data 1
1577 00000e63 * L381:
1578 00000e63 * 206572726F72202D2000 .ascii " error - \0"
1579 00000e6d * .text
1580 00029F78 dd 8f00000e63 pushl $L381
1581 00029F7E fe 08 effffff423 callf $8,_writes
1582 00029F85 # writes( msg );
1583 00029F85 dd ad04 pushl 4(fp)
1584 00029F88 fe 08 effffff419 callf $8,_writes
1585 00029F8F # writec('\n');
1586 00029F8F dd 0a pushl $10
1587 00029F91 fe 08 effffff410 callf $8,_writec
1588 00029F98 # writes(" LNF(op), STF, LNF(0.0), SUBF(op), STF\n");
1589 00029F98 .data 1
1590 00000e6d * L383:
1591 00000e6d * 204C4E46286F70292C2053544 .ascii " LNF(op), STF, LNF(0.0), SUBF(op), STF\12\0"
62C204C4E4628302E30292C20
53554246286F70292C2053544
60A00
1592 00000e95 * .text
1593 00029F98 dd 8f00000e6d pushl $L383
1594 00029F9E fe 08 effffff403 callf $8,_writes
1595 00029FA5 # writes(" operand = ");
1596 00029FA5 .data 1
1597 00000e95 * L384:
1598 00000e95 * 20206F706572616E64203D200 .ascii " operand = \0"
0
1599 00000ea2 * .text
1600 00029FA5 dd 8f00000e95 pushl $L384
1601 00029FAB fe 08 effffff3f6 callf $8,_writes
1602 00029FB2 # write32h( sgl_value_1 );
1603 00029FB2 dd effffff3f0 pushl _sgl_value_1
1604 00029FB8 fe 08 effffff3e9 callf $8,_write32h
1605 00029FBF # writes(", 1st store = ");
1606 00029FBF .data 1
1607 00000ea2 * L385:
1608 00000ea2 * 2C20202020203173742073746 .ascii ", 1st store = \0"
F7265203D2000
1609 00000eb5 * .text
1610 00029FBF dd 8f00000ea2 pushl $L385
1611 00029FC5 fe 08 effffff3dc callf $8,_writes
1612 00029FCC # write32h( sgl_st_acc );
1613 00029FCC dd effffff3d6 pushl _sgl_st_acc
1614 00029FD2 fe 08 effffff3cf callf $8,_write32h
1615 00029FD9 # writes(", data index = ");
1616 00029FD9 .data 1
1617 00000eb5 * L386:
1618 00000eb5 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1619 00000ec7 * .text
1620 00029FD9 dd 8f00000eb5 pushl $L386
1621 00029FDF fe 08 effffff3c2 callf $8,_writes
1622 00029FE6 # writed( index );
1623 00029FE6 dd effffff3bc pushl _index
1624 00029FEC fe 08 effffff3b5 callf $8,_writed
1625 00029FF3 # writec('\n');
1626 00029FF3 dd 0a pushl $10
1627 00029FF5 fe 08 effffff3ac callf $8,_writec
1628 00029FFC # writes("2nd store = ");
1629 00029FFC .data 1
1630 00000ec7 * L387:
1631 00000ec7 * .ascii ""
1632 00000ec7 * 326E642073746F7265203D200 .ascii "2nd store = \0"
0
1633 00000ed4 * .text
1634 00029FFC dd 8f00000ec7 pushl $L387
1635 0002A002 fe 08 effffff39f callf $8,_writes
1636 0002A009 # write32h( sgl_value_6 );
1637 0002A009 dd effffff399 pushl _sgl_value_6
1638 0002A00F fe 08 effffff392 callf $8,_write32h
1639 0002A016 # writes(", expected Acc = ");
1640 0002A016 .data 1
1641 00000ed4 * L388:
1642 00000ed4 * 2C20206578706563746564204 .ascii ", expected Acc = \0"
16363203D2000
1643 00000ee7 * .text
1644 0002A016 dd 8f00000ed4 pushl $L388
1645 0002A01C fe 08 effffff385 callf $8,_writes
1646 0002A023 # write32h( sgl_expected );
1647 0002A023 dd effffff37f pushl _sgl_expected
1648 0002A029 fe 08 effffff378 callf $8,_write32h
1649 0002A030 # writec('\n');
1650 0002A030 dd 0a pushl $10
1651 0002A032 fe 08 effffff36f callf $8,_writec
1652 0002A039 # }
1653 0002A039 40 ret#2
1654 0002A03A .set L372,0x0
1655 0002A03A L374:
1656 0002A03A 13 fee0 jbr L375
1657 0002A03D .data
1658 00000d0c * .text
1659 0002A03D 00 .align 1
1660 0002A03E .globl _pipe5_er_hlt
1661 0002A03E _pipe5_er_hlt:
1662 0002A03E 0000 .word L389
1663 0002A040 #
1664 0002A040 #
1665 0002A040 #
1666 0002A040 #
1667 0002A040 #
1668 0002A040 # /******************************************************************************
1669 0002A040 # *
1670 0002A040 # * HALT ON ERROR ROUTINE
1671 0002A040 # *
1672 0002A040 # * halt with the necessary information saved in the registers
1673 0002A040 # *
1674 0002A040 # ******************************************************************************/
1675 0002A040 # pipe5_er_hlt( subtest )
1676 0002A040 # int subtest;
1677 0002A040 # {
1678 0002A040 11 6e jbr L391
1679 0002A042 L392:
1680 0002A042 # asm("movl _test_no,r0"); /* r0 = test number */
1681 0002A042 0d effffff360 50 movl _test_no,r0
1682 0002A049 # asm("movl _subtest,r1"); /* r1 = subtest number */
1683 0002A049 0d effffff359 51 movl _subtest,r1
1684 0002A050 # asm("movl $1,r2"); /* r2 = error code */
1685 0002A050 0d 01 52 movl $1,r2
1686 0002A053 # asm("movl _cycle,r3"); /* r3 = cycle count */
1687 0002A053 0d effffff34f 53 movl _cycle,r3
1688 0002A05A # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1689 0002A05A 0d effffff348 54 movl _sgl_value_1,r4
1690 0002A061 # asm("movl _sgl_st_acc,r5"); /* r5 = 1st word stored */
1691 0002A061 0d effffff341 55 movl _sgl_st_acc,r5
1692 0002A068 # asm("movl _sgl_value_6,r6"); /* r6 = 2nd word stored */
1693 0002A068 0d effffff33a 56 movl _sgl_value_6,r6
1694 0002A06F # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
1695 0002A06F 0d effffff333 57 movl _sgl_expected,r7
1696 0002A076 # asm("movl _index,r8"); /* r8 = data index */
1697 0002A076 0d effffff32c 58 movl _index,r8
1698 0002A07D # asm("movl _sgl_value_2,r9"); /* r9 = floating zero */
1699 0002A07D 0d effffff325 59 movl _sgl_value_2,r9
1700 0002A084 # if( subtest == 9 ) {
1701 0002A084 1d ad04 09 cmpl 4(fp),$9
1702 0002A088 21 10 jneq L393
1703 0002A08A # asm("movl _sgl_value_5,r10"); /* r10= final SP value */
1704 0002A08A 0d effffff318 5a movl _sgl_value_5,r10
1705 0002A091 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */
1706 0002A091 0d effffff311 5b movl _sgl_value_4,r11
1707 0002A098 # } else
1708 0002A098 11 14 jbr L394
1709 0002A09A L393:
1710 0002A09A # if( subtest == 10 ) {
1711 0002A09A 1d ad04 0a cmpl 4(fp),$10
1712 0002A09E 21 0e jneq L395
1713 0002A0A0 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */
1714 0002A0A0 0d effffff302 5a movl _sgl_value_5,r10
1715 0002A0A7 # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */
1716 0002A0A7 0d effffff2fb 5b movl _sgl_value_4,r11
1717 0002A0AE # };
1718 0002A0AE L395:
1719 0002A0AE L394:
1720 0002A0AE # asm(".globl _pipe5_1_hlt");
1721 0002A0AE .globl _pipe5_1_hlt
1722 0002A0AE # asm("_pipe5_1_hlt:"); /* PC after the halt */
1723 0002A0AE _pipe5_1_hlt:
1724 0002A0AE # asm("halt"); /* HALT ... */
1725 0002A0AE 00 halt
1726 0002A0AF # } /* end of halt on error */
1727 0002A0AF 40 ret#2
1728 0002A0B0 .set L389,0x0
1729 0002A0B0 L391:
1730 0002A0B0 11 90 jbr L392
1731 0002A0B2 .data
1731 0005345A .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.