![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe4.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 pipe4.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 00000d78 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_4
6 00000000 _pipe_4:
7 00028630 0000 .word L215
8 00028632 # #include "fpp_defs.h"
9 00028632 #
10 00028632 #
11 00028632 # /*****************************************************************************
12 00028632 # *
13 00028632 # * PIPELINE TEST #4 MONITOR
14 00028632 # *
15 00028632 # * This test will do:
16 00028632 # *
17 00028632 # * LDF(x) STF LDF(1) MULF(1) MULF(x) STF
18 00028632 # *
19 00028632 # * where x is the fmacro1 LDF data. This test verifies the store after the
20 00028632 # * LDF and the LDF after the store. It will also verify all of the MULF's
21 00028632 # * B entry points.
22 00028632 # *****************************************************************************/
23 00028632 # pipe_4()
24 00028632 # {
25 00028632 13 00a8 jbr L217
26 00028635 L218:
27 00028635 # asm(".globl _pipeline_4_t");
28 00028635 .globl _pipeline_4_t
29 00028635 # asm("_pipeline_4_t:"); /* entry address */
30 00028635 _pipeline_4_t:
31 00028635 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32 00028635 1d effffffff5 01 cmpl _cycle,$1
33 0002863C 21 15 jneq L219
34 0002863E 5d efffffffec tstl _prt_hdrs
35 00028644 31 0d jeql L219
36 00028646 # {
37 00028646 # writes(" PIPE_4 ");
38 00028646 .data 1
39 00000d78 * L221:
40 00000d78 * 20504950455F342000 .ascii " PIPE_4 \0"
41 00000d81 * .text
42 00028646 dd 8f00000d78 pushl $L221
43 0002864C fe 08 efffffffdd callf $8,_writes
44 00028653 # }
45 00028653 # subtest = 1;
46 00028653 L219:
47 00028653 0d 01 efffffffd6 movl $1,_subtest
48 0002865A # pipe4_1(); /* data in REGs, no NOPs */
49 0002865A fe 04 ef0000007f callf $4,_pipe4_1
50 00028661 # subtest++; /* increment subtest num */
51 00028661 6d efffffffc9 incl _subtest
52 00028667 # pipe4_2(); /* data in REGs, 1 NOP */
53 00028667 fe 04 ef00000166 callf $4,_pipe4_2
54 0002866E # subtest++; /* increment subtest num */
55 0002866E 6d efffffffbc incl _subtest
56 00028674 # pipe4_3(); /* data in REGs, 2 NOPs */
57 00028674 fe 04 ef00000251 callf $4,_pipe4_3
58 0002867B # subtest++; /* increment subtest num */
59 0002867B 6d efffffffaf incl _subtest
60 00028681 # pipe4_4(); /* data in REGs, 3 NOPs */
61 00028681 fe 04 ef00000342 callf $4,_pipe4_4
62 00028688 # subtest++; /* increment subtest num */
63 00028688 6d efffffffa2 incl _subtest
64 0002868E # pipe4_5(); /* data in CACHE, no NOPs */
65 0002868E fe 04 ef00000437 callf $4,_pipe4_5
66 00028695 # subtest++; /* increment subtest num */
67 00028695 6d efffffff95 incl _subtest
68 0002869B # pipe4_6(); /* data in CACHE, 1 NOP */
69 0002869B fe 04 ef0000051a callf $4,_pipe4_6
70 000286A2 # subtest++; /* increment subtest num */
71 000286A2 6d efffffff88 incl _subtest
72 000286A8 # pipe4_7(); /* data in CACHE, 2 NOPs */
73 000286A8 fe 04 ef00000601 callf $4,_pipe4_7
74 000286AF # subtest++; /* increment subtest num */
75 000286AF 6d efffffff7b incl _subtest
76 000286B5 # pipe4_8(); /* data in CACHE, 3 NOPs */
77 000286B5 fe 04 ef000006ee callf $4,_pipe4_8
78 000286BC # subtest++; /* increment subtest num */
79 000286BC 6d efffffff6e incl _subtest
80 000286C2 # pipe4_9(); /* data on STACK, no NOPs */
81 000286C2 fe 04 ef000007df callf $4,_pipe4_9
82 000286C9 # subtest++; /* increment subtest num */
83 000286C9 6d efffffff61 incl _subtest
84 000286CF # pipe4_10(); /* data via FP no NOPs */
85 000286CF fe 04 ef00000968 callf $4,_pipe4_10
86 000286D6 # asm("jmp *return"); /* return to the test monitor */
87 000286D6 71 ffffffff54 jmp *return
88 000286DC # }
89 000286DC 40 ret#2
90 000286DD .set L215,0x0
91 000286DD L217:
92 000286DD 13 ff55 jbr L218
93 000286E0 .data
94 00000d78 * .text
95 000286E0 .align 1
96 000286E0 .globl _pipe4_1
97 000286E0 _pipe4_1:
98 000286E0 0000 .word L232
99 000286E2 #
100 000286E2 #
101 000286E2 #
102 000286E2 #
103 000286E2 #
104 000286E2 #
105 000286E2 # /************************************************************************
106 000286E2 # *
107 000286E2 # * SUBTEST 1
108 000286E2 # * data in registers, no NO-OPs
109 000286E2 # *
110 000286E2 # ************************************************************************/
111 000286E2 # pipe4_1()
112 000286E2 # {
113 000286E2 13 00eb jbr L234
114 000286E5 L235:
115 000286E5 # force_loop = FALSE; /* clear force_loop flag */
116 000286E5 4d efffffff45 clrl _force_loop
117 000286EB # index = 0;
118 000286EB 4d efffffff3f clrl _index
119 000286F1 # do
120 000286F1 L238:
121 000286F1 # {
122 000286F1 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
123 000286F1 0d efffffff39 50 movl _index,r0
124 000286F8 48 03 50 50 shll $3,r0,r0
125 000286FC 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
126 00028707 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
127 00028707 0d efffffff23 50 movl _index,r0
128 0002870E 48 03 50 50 shll $3,r0,r0
129 00028712 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
130 0002871D # sgl_value_2 = 0x40800000; /* floating '1' */
131 0002871D 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
132 00028728 # /*
133 00028728 # * If LOOP ON ERROR is set, this is the loop for this subtest.
134 00028728 # * The force loop flag is set after the first error.
135 00028728 # */
136 00028728 # asm("_pipe4_1_lp1:");
137 00028728 _pipe4_1_lp1:
138 00028728 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
139 00028728 0d efffffff02 54 movl _sgl_value_1,r4
140 0002872F # asm("movl _sgl_value_2,r5"); /* move data to r5 */
141 0002872F 0d effffffefb 55 movl _sgl_value_2,r5
142 00028736 # asm("ldf r4"); /* load the operand */
143 00028736 06 54 ldf r4
144 00028738 # asm("stf r7"); /* store the result */
145 00028738 26 57 stf r7
146 0002873A # asm("ldf r5"); /* load a floating '1' */
147 0002873A 06 55 ldf r5
148 0002873C # asm("mulf r5"); /* multipy by a '1' */
149 0002873C e6 55 mulf r5
150 0002873E # asm("mulf r4"); /* multipy by the operand */
151 0002873E e6 54 mulf r4
152 00028740 # asm("stf r8"); /* store the result */
153 00028740 26 58 stf r8
154 00028742 # if( force_loop );
155 00028742 5d effffffee8 tstl _force_loop
156 00028748 31 00 jeql L239
157 0002874A # asm("brb _pipe4_1_lp1");; /* loop on the error */
158 0002874A L239:
159 0002874A 11 dc brb _pipe4_1_lp1
160 0002874C # /*
161 0002874C # * verify the results
162 0002874C # */
163 0002874C # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
164 0002874C 0d 57 effffffedd movl r7,_sgl_st_acc
165 00028753 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
166 00028753 0d 58 effffffed6 movl r8,_sgl_value_6
167 0002875A # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
168 0002875A # (sgl_value_6 != sgl_expected) )
169 0002875A 1d effffffed0 effffffecb cmpl _sgl_st_acc,_sgl_expected
170 00028765 21 0d jneq L9999
171 00028767 1d effffffec3 effffffebe cmpl _sgl_value_6,_sgl_expected
172 00028772 31 42 jeql L240
173 00028774 L9999:
174 00028774 # {
175 00028774 # errcnt++; /* bump the error count */
176 00028774 6d effffffeb6 incl _errcnt
177 0002877A # if ( prt_error )
178 0002877A 5d effffffeb0 tstl _prt_error
179 00028780 31 0d jeql L241
180 00028782 # print_pipe4_er("Reg. Data, no NO-OPs");
181 00028782 .data 1
182 00000d81 * L243:
183 00000d81 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
F204E4F2D4F507300
184 00000d96 * .text
185 00028782 dd 8f00000d81 pushl $L243
186 00028788 fe 08 ef00000a7f callf $8,_print_pipe4_er
187 0002878F # if ( halt_flg )
188 0002878F L241:
189 0002878F 5d effffffe9b tstl _halt_flg
190 00028795 31 0d jeql L244
191 00028797 # pipe4_er_hlt( subtest );
192 00028797 dd effffffe93 pushl _subtest
193 0002879D fe 08 ef00000b90 callf $8,_pipe4_er_hlt
194 000287A4 # if ( loop_on_err ) {
195 000287A4 L244:
196 000287A4 5d effffffe86 tstl _loop_on_err
197 000287AA 31 0a jeql L246
198 000287AC # force_loop = TRUE; /* set the force loop flag */
199 000287AC 0d 01 effffffe7d movl $1,_force_loop
200 000287B3 # asm("brw _pipe4_1_lp1"); /* and loop */
201 000287B3 13 ff72 brw _pipe4_1_lp1
202 000287B6 # }
203 000287B6 # } /* end of compare error */
204 000287B6 L246:
205 000287B6 # } while( index++ < max_ldf_1_index );
206 000287B6 L240:
207 000287B6 L237:
208 000287B6 0d effffffe74 50 movl _index,r0
209 000287BD 6d effffffe6d incl _index
210 000287C3 1d 50 effffffe66 cmpl r0,_max_ldf_1_index
211 000287CA 81 03 13 ff22 jlss L238
212 000287CF L236:
213 000287CF # } /* end of subtest 1 */
214 000287CF 40 ret#2
215 000287D0 .set L232,0x0
216 000287D0 L234:
217 000287D0 13 ff12 jbr L235
218 000287D3 .data
219 00000d78 * .text
220 000287D3 00 .align 1
221 000287D4 .globl _pipe4_2
222 000287D4 _pipe4_2:
223 000287D4 0000 .word L247
224 000287D6 #
225 000287D6 #
226 000287D6 #
227 000287D6 #
228 000287D6 #
229 000287D6 #
230 000287D6 # /************************************************************************
231 000287D6 # *
232 000287D6 # * SUBTEST 2
233 000287D6 # * data in registers, 1 NO-OP
234 000287D6 # *
235 000287D6 # ************************************************************************/
236 000287D6 # pipe4_2()
237 000287D6 # {
238 000287D6 13 00f0 jbr L249
239 000287D9 L250:
240 000287D9 # force_loop = FALSE; /* clear force_loop flag */
241 000287D9 4d effffffe51 clrl _force_loop
242 000287DF # index = 0;
243 000287DF 4d effffffe4b clrl _index
244 000287E5 # do
245 000287E5 L253:
246 000287E5 # {
247 000287E5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
248 000287E5 0d effffffe45 50 movl _index,r0
249 000287EC 48 03 50 50 shll $3,r0,r0
250 000287F0 0d e000000000 effffffe35 movl _ldf_1_data(r0),_sgl_value_1
251 000287FB # sgl_expected = ldf_1_data[index].exp; /* get expected results */
252 000287FB 0d effffffe2f 50 movl _index,r0
253 00028802 48 03 50 50 shll $3,r0,r0
254 00028806 0d e000000004 effffffe1f movl _ldf_1_data+4(r0),_sgl_expected
255 00028811 # sgl_value_2 = 0x40800000; /* floating '1' */
256 00028811 0d 8f40800000 effffffe14 movl $1082130432,_sgl_value_2
257 0002881C # /*
258 0002881C # * If LOOP ON ERROR is set, this is the loop for this subtest.
259 0002881C # * The force loop flag is set after the first error.
260 0002881C # */
261 0002881C # asm("_pipe4_2_lp1:");
262 0002881C _pipe4_2_lp1:
263 0002881C # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
264 0002881C 0d effffffe0e 54 movl _sgl_value_1,r4
265 00028823 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
266 00028823 0d effffffe07 55 movl _sgl_value_2,r5
267 0002882A # asm("ldf r4"); /* load the operand */
268 0002882A 06 54 ldf r4
269 0002882C # asm("nop");
270 0002882C 10 nop
271 0002882D # asm("stf r7"); /* store the result */
272 0002882D 26 57 stf r7
273 0002882F # asm("nop");
274 0002882F 10 nop
275 00028830 # asm("ldf r5"); /* load a floating '1' */
276 00028830 06 55 ldf r5
277 00028832 # asm("nop");
278 00028832 10 nop
279 00028833 # asm("mulf r5"); /* multipy by a '1' */
280 00028833 e6 55 mulf r5
281 00028835 # asm("nop");
282 00028835 10 nop
283 00028836 # asm("mulf r4"); /* multipy by the operand */
284 00028836 e6 54 mulf r4
285 00028838 # asm("nop");
286 00028838 10 nop
287 00028839 # asm("stf r8"); /* store the result */
288 00028839 26 58 stf r8
289 0002883B # if( force_loop );
290 0002883B 5d effffffdef tstl _force_loop
291 00028841 31 00 jeql L254
292 00028843 # asm("brb _pipe4_2_lp1");; /* loop on the error */
293 00028843 L254:
294 00028843 11 d7 brb _pipe4_2_lp1
295 00028845 # /*
296 00028845 # * verify the results
297 00028845 # */
298 00028845 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
299 00028845 0d 57 effffffde4 movl r7,_sgl_st_acc
300 0002884C # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
301 0002884C 0d 58 effffffddd movl r8,_sgl_value_6
302 00028853 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
303 00028853 # (sgl_value_6 != sgl_expected) )
304 00028853 1d effffffdd7 effffffdd2 cmpl _sgl_st_acc,_sgl_expected
305 0002885E 21 0d jneq L9998
306 00028860 1d effffffdca effffffdc5 cmpl _sgl_value_6,_sgl_expected
307 0002886B 31 42 jeql L255
308 0002886D L9998:
309 0002886D # {
310 0002886D # errcnt++; /* bump the error count */
311 0002886D 6d effffffdbd incl _errcnt
312 00028873 # if ( prt_error )
313 00028873 5d effffffdb7 tstl _prt_error
314 00028879 31 0d jeql L256
315 0002887B # print_pipe4_er("Reg. Data, 1 NO-OP");
316 0002887B .data 1
317 00000d96 * L257:
318 00000d96 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
319 00000da9 * .text
320 0002887B dd 8f00000d96 pushl $L257
321 00028881 fe 08 ef00000986 callf $8,_print_pipe4_er
322 00028888 # if ( halt_flg )
323 00028888 L256:
324 00028888 5d effffffda2 tstl _halt_flg
325 0002888E 31 0d jeql L258
326 00028890 # pipe4_er_hlt( subtest );
327 00028890 dd effffffd9a pushl _subtest
328 00028896 fe 08 ef00000a97 callf $8,_pipe4_er_hlt
329 0002889D # if ( loop_on_err ) {
330 0002889D L258:
331 0002889D 5d effffffd8d tstl _loop_on_err
332 000288A3 31 0a jeql L259
333 000288A5 # force_loop = TRUE; /* set the force loop flag */
334 000288A5 0d 01 effffffd84 movl $1,_force_loop
335 000288AC # asm("brw _pipe4_2_lp1"); /* and loop */
336 000288AC 13 ff6d brw _pipe4_2_lp1
337 000288AF # }
338 000288AF # } /* end of compare error */
339 000288AF L259:
340 000288AF # } while( index++ < max_ldf_1_index );
341 000288AF L255:
342 000288AF L252:
343 000288AF 0d effffffd7b 50 movl _index,r0
344 000288B6 6d effffffd74 incl _index
345 000288BC 1d 50 effffffd6d cmpl r0,_max_ldf_1_index
346 000288C3 81 03 13 ff1d jlss L253
347 000288C8 L251:
348 000288C8 # } /* end of subtest 2 */
349 000288C8 40 ret#2
350 000288C9 .set L247,0x0
351 000288C9 L249:
352 000288C9 13 ff0d jbr L250
353 000288CC .data
354 00000d78 * .text
355 000288CC .align 1
356 000288CC .globl _pipe4_3
357 000288CC _pipe4_3:
358 000288CC 0000 .word L260
359 000288CE #
360 000288CE #
361 000288CE #
362 000288CE #
363 000288CE #
364 000288CE #
365 000288CE # /************************************************************************
366 000288CE # *
367 000288CE # * SUBTEST 3
368 000288CE # * data in registers, 2 NO-OPs
369 000288CE # *
370 000288CE # ************************************************************************/
371 000288CE # pipe4_3()
372 000288CE # {
373 000288CE 13 00f5 jbr L262
374 000288D1 L263:
375 000288D1 # force_loop = FALSE; /* clear force_loop flag */
376 000288D1 4d effffffd59 clrl _force_loop
377 000288D7 # index = 0;
378 000288D7 4d effffffd53 clrl _index
379 000288DD # do
380 000288DD L266:
381 000288DD # {
382 000288DD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
383 000288DD 0d effffffd4d 50 movl _index,r0
384 000288E4 48 03 50 50 shll $3,r0,r0
385 000288E8 0d e000000000 effffffd3d movl _ldf_1_data(r0),_sgl_value_1
386 000288F3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
387 000288F3 0d effffffd37 50 movl _index,r0
388 000288FA 48 03 50 50 shll $3,r0,r0
389 000288FE 0d e000000004 effffffd27 movl _ldf_1_data+4(r0),_sgl_expected
390 00028909 # sgl_value_2 = 0x40800000; /* floating '1' */
391 00028909 0d 8f40800000 effffffd1c movl $1082130432,_sgl_value_2
392 00028914 # /*
393 00028914 # * If LOOP ON ERROR is set, this is the loop for this subtest.
394 00028914 # * The force loop flag is set after the first error.
395 00028914 # */
396 00028914 # asm("_pipe4_3_lp1:");
397 00028914 _pipe4_3_lp1:
398 00028914 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
399 00028914 0d effffffd16 54 movl _sgl_value_1,r4
400 0002891B # asm("movl _sgl_value_2,r5"); /* move data to r5 */
401 0002891B 0d effffffd0f 55 movl _sgl_value_2,r5
402 00028922 # asm("ldf r4"); /* load the operand */
403 00028922 06 54 ldf r4
404 00028924 # asm("nop");
405 00028924 10 nop
406 00028925 # asm("nop");
407 00028925 10 nop
408 00028926 # asm("stf r7"); /* store the result */
409 00028926 26 57 stf r7
410 00028928 # asm("nop");
411 00028928 10 nop
412 00028929 # asm("nop");
413 00028929 10 nop
414 0002892A # asm("ldf r5"); /* load a floating '1' */
415 0002892A 06 55 ldf r5
416 0002892C # asm("nop");
417 0002892C 10 nop
418 0002892D # asm("nop");
419 0002892D 10 nop
420 0002892E # asm("mulf r5"); /* multipy by a '1' */
421 0002892E e6 55 mulf r5
422 00028930 # asm("nop");
423 00028930 10 nop
424 00028931 # asm("nop");
425 00028931 10 nop
426 00028932 # asm("mulf r4"); /* multipy by the operand */
427 00028932 e6 54 mulf r4
428 00028934 # asm("nop");
429 00028934 10 nop
430 00028935 # asm("nop");
431 00028935 10 nop
432 00028936 # asm("stf r8"); /* store the result */
433 00028936 26 58 stf r8
434 00028938 # if( force_loop );
435 00028938 5d effffffcf2 tstl _force_loop
436 0002893E 31 00 jeql L267
437 00028940 # asm("brb _pipe4_3_lp1");; /* loop on the error */
438 00028940 L267:
439 00028940 11 d2 brb _pipe4_3_lp1
440 00028942 # /*
441 00028942 # * verify the results
442 00028942 # */
443 00028942 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
444 00028942 0d 57 effffffce7 movl r7,_sgl_st_acc
445 00028949 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
446 00028949 0d 58 effffffce0 movl r8,_sgl_value_6
447 00028950 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
448 00028950 # (sgl_value_6 != sgl_expected) )
449 00028950 1d effffffcda effffffcd5 cmpl _sgl_st_acc,_sgl_expected
450 0002895B 21 0d jneq L9997
451 0002895D 1d effffffccd effffffcc8 cmpl _sgl_value_6,_sgl_expected
452 00028968 31 42 jeql L268
453 0002896A L9997:
454 0002896A # {
455 0002896A # errcnt++; /* bump the error count */
456 0002896A 6d effffffcc0 incl _errcnt
457 00028970 # if ( prt_error )
458 00028970 5d effffffcba tstl _prt_error
459 00028976 31 0d jeql L269
460 00028978 # print_pipe4_er("Reg. Data, 2 NO-OPs");
461 00028978 .data 1
462 00000da9 * L270:
463 00000da9 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
04E4F2D4F507300
464 00000dbd * .text
465 00028978 dd 8f00000da9 pushl $L270
466 0002897E fe 08 ef00000889 callf $8,_print_pipe4_er
467 00028985 # if ( halt_flg )
468 00028985 L269:
469 00028985 5d effffffca5 tstl _halt_flg
470 0002898B 31 0d jeql L271
471 0002898D # pipe4_er_hlt( subtest );
472 0002898D dd effffffc9d pushl _subtest
473 00028993 fe 08 ef0000099a callf $8,_pipe4_er_hlt
474 0002899A # if ( loop_on_err ) {
475 0002899A L271:
476 0002899A 5d effffffc90 tstl _loop_on_err
477 000289A0 31 0a jeql L272
478 000289A2 # force_loop = TRUE; /* set the force loop flag */
479 000289A2 0d 01 effffffc87 movl $1,_force_loop
480 000289A9 # asm("brw _pipe4_3_lp1"); /* and loop */
481 000289A9 13 ff68 brw _pipe4_3_lp1
482 000289AC # }
483 000289AC # } /* end of compare error */
484 000289AC L272:
485 000289AC # } while( index++ < max_ldf_1_index );
486 000289AC L268:
487 000289AC L265:
488 000289AC 0d effffffc7e 50 movl _index,r0
489 000289B3 6d effffffc77 incl _index
490 000289B9 1d 50 effffffc70 cmpl r0,_max_ldf_1_index
491 000289C0 81 03 13 ff18 jlss L266
492 000289C5 L264:
493 000289C5 # } /* end of subtest 3 */
494 000289C5 40 ret#2
495 000289C6 .set L260,0x0
496 000289C6 L262:
497 000289C6 13 ff08 jbr L263
498 000289C9 .data
499 00000d78 * .text
500 000289C9 00 .align 1
501 000289CA .globl _pipe4_4
502 000289CA _pipe4_4:
503 000289CA 0000 .word L273
504 000289CC #
505 000289CC #
506 000289CC #
507 000289CC #
508 000289CC #
509 000289CC #
510 000289CC # /************************************************************************
511 000289CC # *
512 000289CC # * SUBTEST 4
513 000289CC # * data in registers, 3 NO-OPs
514 000289CC # *
515 000289CC # ************************************************************************/
516 000289CC # pipe4_4()
517 000289CC # {
518 000289CC 13 00fa jbr L275
519 000289CF L276:
520 000289CF # force_loop = FALSE; /* clear force_loop flag */
521 000289CF 4d effffffc5b clrl _force_loop
522 000289D5 # index = 0;
523 000289D5 4d effffffc55 clrl _index
524 000289DB # do
525 000289DB L279:
526 000289DB # {
527 000289DB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
528 000289DB 0d effffffc4f 50 movl _index,r0
529 000289E2 48 03 50 50 shll $3,r0,r0
530 000289E6 0d e000000000 effffffc3f movl _ldf_1_data(r0),_sgl_value_1
531 000289F1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
532 000289F1 0d effffffc39 50 movl _index,r0
533 000289F8 48 03 50 50 shll $3,r0,r0
534 000289FC 0d e000000004 effffffc29 movl _ldf_1_data+4(r0),_sgl_expected
535 00028A07 # sgl_value_2 = 0x40800000; /* floating '1' */
536 00028A07 0d 8f40800000 effffffc1e movl $1082130432,_sgl_value_2
537 00028A12 # /*
538 00028A12 # * If LOOP ON ERROR is set, this is the loop for this subtest.
539 00028A12 # * The force loop flag is set after the first error.
540 00028A12 # */
541 00028A12 # asm("_pipe4_4_lp1:");
542 00028A12 _pipe4_4_lp1:
543 00028A12 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
544 00028A12 0d effffffc18 54 movl _sgl_value_1,r4
545 00028A19 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
546 00028A19 0d effffffc11 55 movl _sgl_value_2,r5
547 00028A20 # asm("ldf r4"); /* load the operand */
548 00028A20 06 54 ldf r4
549 00028A22 # asm("nop");
550 00028A22 10 nop
551 00028A23 # asm("nop");
552 00028A23 10 nop
553 00028A24 # asm("nop");
554 00028A24 10 nop
555 00028A25 # asm("stf r7"); /* store the result */
556 00028A25 26 57 stf r7
557 00028A27 # asm("nop");
558 00028A27 10 nop
559 00028A28 # asm("nop");
560 00028A28 10 nop
561 00028A29 # asm("nop");
562 00028A29 10 nop
563 00028A2A # asm("ldf r5"); /* load a floating '1' */
564 00028A2A 06 55 ldf r5
565 00028A2C # asm("nop");
566 00028A2C 10 nop
567 00028A2D # asm("nop");
568 00028A2D 10 nop
569 00028A2E # asm("nop");
570 00028A2E 10 nop
571 00028A2F # asm("mulf r5"); /* multipy by a '1' */
572 00028A2F e6 55 mulf r5
573 00028A31 # asm("nop");
574 00028A31 10 nop
575 00028A32 # asm("nop");
576 00028A32 10 nop
577 00028A33 # asm("nop");
578 00028A33 10 nop
579 00028A34 # asm("mulf r4"); /* multipy by the operand */
580 00028A34 e6 54 mulf r4
581 00028A36 # asm("nop");
582 00028A36 10 nop
583 00028A37 # asm("nop");
584 00028A37 10 nop
585 00028A38 # asm("nop");
586 00028A38 10 nop
587 00028A39 # asm("stf r8"); /* store the result */
588 00028A39 26 58 stf r8
589 00028A3B # if( force_loop );
590 00028A3B 5d effffffbef tstl _force_loop
591 00028A41 31 00 jeql L280
592 00028A43 # asm("brb _pipe4_4_lp1");; /* loop on the error */
593 00028A43 L280:
594 00028A43 11 cd brb _pipe4_4_lp1
595 00028A45 # /*
596 00028A45 # * verify the results
597 00028A45 # */
598 00028A45 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
599 00028A45 0d 57 effffffbe4 movl r7,_sgl_st_acc
600 00028A4C # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
601 00028A4C 0d 58 effffffbdd movl r8,_sgl_value_6
602 00028A53 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
603 00028A53 # (sgl_value_6 != sgl_expected) )
604 00028A53 1d effffffbd7 effffffbd2 cmpl _sgl_st_acc,_sgl_expected
605 00028A5E 21 0d jneq L9996
606 00028A60 1d effffffbca effffffbc5 cmpl _sgl_value_6,_sgl_expected
607 00028A6B 31 42 jeql L281
608 00028A6D L9996:
609 00028A6D # {
610 00028A6D # errcnt++; /* bump the error count */
611 00028A6D 6d effffffbbd incl _errcnt
612 00028A73 # if ( prt_error )
613 00028A73 5d effffffbb7 tstl _prt_error
614 00028A79 31 0d jeql L282
615 00028A7B # print_pipe4_er("Reg. Data, 3 NO-OPs");
616 00028A7B .data 1
617 00000dbd * L283:
618 00000dbd * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
04E4F2D4F507300
619 00000dd1 * .text
620 00028A7B dd 8f00000dbd pushl $L283
621 00028A81 fe 08 ef00000786 callf $8,_print_pipe4_er
622 00028A88 # if ( halt_flg )
623 00028A88 L282:
624 00028A88 5d effffffba2 tstl _halt_flg
625 00028A8E 31 0d jeql L284
626 00028A90 # pipe4_er_hlt( subtest );
627 00028A90 dd effffffb9a pushl _subtest
628 00028A96 fe 08 ef00000897 callf $8,_pipe4_er_hlt
629 00028A9D # if ( loop_on_err ) {
630 00028A9D L284:
631 00028A9D 5d effffffb8d tstl _loop_on_err
632 00028AA3 31 0a jeql L285
633 00028AA5 # force_loop = TRUE; /* set the force loop flag */
634 00028AA5 0d 01 effffffb84 movl $1,_force_loop
635 00028AAC # asm("brw _pipe4_4_lp1"); /* and loop */
636 00028AAC 13 ff63 brw _pipe4_4_lp1
637 00028AAF # }
638 00028AAF # } /* end of compare error */
639 00028AAF L285:
640 00028AAF # } while( index++ < max_ldf_1_index );
641 00028AAF L281:
642 00028AAF L278:
643 00028AAF 0d effffffb7b 50 movl _index,r0
644 00028AB6 6d effffffb74 incl _index
645 00028ABC 1d 50 effffffb6d cmpl r0,_max_ldf_1_index
646 00028AC3 81 03 13 ff13 jlss L279
647 00028AC8 L277:
648 00028AC8 # } /* end of subtest 4 */
649 00028AC8 40 ret#2
650 00028AC9 .set L273,0x0
651 00028AC9 L275:
652 00028AC9 13 ff03 jbr L276
653 00028ACC .data
654 00000d78 * .text
655 00028ACC .align 1
656 00028ACC .globl _pipe4_5
657 00028ACC _pipe4_5:
658 00028ACC 0000 .word L286
659 00028ACE #
660 00028ACE #
661 00028ACE #
662 00028ACE #
663 00028ACE #
664 00028ACE #
665 00028ACE #
666 00028ACE # /************************************************************************
667 00028ACE # *
668 00028ACE # * SUBTEST 5
669 00028ACE # * data in Cache, no NO-OPs
670 00028ACE # *
671 00028ACE # ************************************************************************/
672 00028ACE # pipe4_5()
673 00028ACE # {
674 00028ACE 13 00e7 jbr L288
675 00028AD1 L289:
676 00028AD1 # force_loop = FALSE; /* clear force_loop flag */
677 00028AD1 4d effffffb59 clrl _force_loop
678 00028AD7 # index = 0;
679 00028AD7 4d effffffb53 clrl _index
680 00028ADD # do
681 00028ADD L292:
682 00028ADD # {
683 00028ADD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
684 00028ADD 0d effffffb4d 50 movl _index,r0
685 00028AE4 48 03 50 50 shll $3,r0,r0
686 00028AE8 0d e000000000 effffffb3d movl _ldf_1_data(r0),_sgl_value_1
687 00028AF3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
688 00028AF3 0d effffffb37 50 movl _index,r0
689 00028AFA 48 03 50 50 shll $3,r0,r0
690 00028AFE 0d e000000004 effffffb27 movl _ldf_1_data+4(r0),_sgl_expected
691 00028B09 # sgl_value_2 = 0x40800000; /* floating '1' */
692 00028B09 0d 8f40800000 effffffb1c movl $1082130432,_sgl_value_2
693 00028B14 # /*
694 00028B14 # * If LOOP ON ERROR is set, this is the loop for this subtest.
695 00028B14 # * The force loop flag is set after the first error.
696 00028B14 # */
697 00028B14 # asm("_pipe4_5_lp1:");
698 00028B14 _pipe4_5_lp1:
699 00028B14 # asm("ldf _sgl_value_1"); /* load the operand */
700 00028B14 06 effffffb16 ldf _sgl_value_1
701 00028B1A # asm("stf _sgl_st_acc"); /* store the result */
702 00028B1A 26 effffffb10 stf _sgl_st_acc
703 00028B20 # asm("ldf _sgl_value_2"); /* load a floating '1' */
704 00028B20 06 effffffb0a ldf _sgl_value_2
705 00028B26 # asm("mulf _sgl_value_2"); /* multipy by a '1' */
706 00028B26 e6 effffffb04 mulf _sgl_value_2
707 00028B2C # asm("mulf _sgl_value_1"); /* multipy by the operand */
708 00028B2C e6 effffffafe mulf _sgl_value_1
709 00028B32 # asm("stf _sgl_value_6"); /* store the result */
710 00028B32 26 effffffaf8 stf _sgl_value_6
711 00028B38 # if( force_loop );
712 00028B38 5d effffffaf2 tstl _force_loop
713 00028B3E 31 00 jeql L293
714 00028B40 # asm("brb _pipe4_5_lp1");; /* loop on the error */
715 00028B40 L293:
716 00028B40 11 d2 brb _pipe4_5_lp1
717 00028B42 # /*
718 00028B42 # * verify the results
719 00028B42 # */
720 00028B42 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
721 00028B42 # (sgl_value_6 != sgl_expected) )
722 00028B42 1d effffffae8 effffffae3 cmpl _sgl_st_acc,_sgl_expected
723 00028B4D 21 0d jneq L9995
724 00028B4F 1d effffffadb effffffad6 cmpl _sgl_value_6,_sgl_expected
725 00028B5A 31 42 jeql L294
726 00028B5C L9995:
727 00028B5C # {
728 00028B5C # errcnt++; /* bump the error count */
729 00028B5C 6d efffffface incl _errcnt
730 00028B62 # if ( prt_error )
731 00028B62 5d effffffac8 tstl _prt_error
732 00028B68 31 0d jeql L295
733 00028B6A # print_pipe4_er("Cache Data, no NO-OPs");
734 00028B6A .data 1
735 00000dd1 * L296:
736 00000dd1 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
E6F204E4F2D4F507300
737 00000de7 * .text
738 00028B6A dd 8f00000dd1 pushl $L296
739 00028B70 fe 08 ef00000697 callf $8,_print_pipe4_er
740 00028B77 # if ( halt_flg )
741 00028B77 L295:
742 00028B77 5d effffffab3 tstl _halt_flg
743 00028B7D 31 0d jeql L297
744 00028B7F # pipe4_er_hlt( subtest );
745 00028B7F dd effffffaab pushl _subtest
746 00028B85 fe 08 ef000007a8 callf $8,_pipe4_er_hlt
747 00028B8C # if ( loop_on_err ) {
748 00028B8C L297:
749 00028B8C 5d effffffa9e tstl _loop_on_err
750 00028B92 31 0a jeql L298
751 00028B94 # force_loop = TRUE; /* set the force loop flag */
752 00028B94 0d 01 effffffa95 movl $1,_force_loop
753 00028B9B # asm("brw _pipe4_5_lp1"); /* and loop */
754 00028B9B 13 ff76 brw _pipe4_5_lp1
755 00028B9E # }
756 00028B9E # } /* end of compare error */
757 00028B9E L298:
758 00028B9E # } while( index++ < max_ldf_1_index );
759 00028B9E L294:
760 00028B9E L291:
761 00028B9E 0d effffffa8c 50 movl _index,r0
762 00028BA5 6d effffffa85 incl _index
763 00028BAB 1d 50 effffffa7e cmpl r0,_max_ldf_1_index
764 00028BB2 81 03 13 ff26 jlss L292
765 00028BB7 L290:
766 00028BB7 # } /* end of subtest 5 */
767 00028BB7 40 ret#2
768 00028BB8 .set L286,0x0
769 00028BB8 L288:
770 00028BB8 13 ff16 jbr L289
771 00028BBB .data
772 00000d78 * .text
773 00028BBB 00 .align 1
774 00028BBC .globl _pipe4_6
775 00028BBC _pipe4_6:
776 00028BBC 0000 .word L299
777 00028BBE #
778 00028BBE #
779 00028BBE #
780 00028BBE #
781 00028BBE #
782 00028BBE #
783 00028BBE # /************************************************************************
784 00028BBE # *
785 00028BBE # * SUBTEST 6
786 00028BBE # * data in Cache, 1 NO-OP
787 00028BBE # *
788 00028BBE # ************************************************************************/
789 00028BBE # pipe4_6()
790 00028BBE # {
791 00028BBE 13 00ec jbr L301
792 00028BC1 L302:
793 00028BC1 # force_loop = FALSE; /* clear force_loop flag */
794 00028BC1 4d effffffa69 clrl _force_loop
795 00028BC7 # index = 0;
796 00028BC7 4d effffffa63 clrl _index
797 00028BCD # do
798 00028BCD L305:
799 00028BCD # {
800 00028BCD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
801 00028BCD 0d effffffa5d 50 movl _index,r0
802 00028BD4 48 03 50 50 shll $3,r0,r0
803 00028BD8 0d e000000000 effffffa4d movl _ldf_1_data(r0),_sgl_value_1
804 00028BE3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
805 00028BE3 0d effffffa47 50 movl _index,r0
806 00028BEA 48 03 50 50 shll $3,r0,r0
807 00028BEE 0d e000000004 effffffa37 movl _ldf_1_data+4(r0),_sgl_expected
808 00028BF9 # sgl_value_2 = 0x40800000; /* floating '1' */
809 00028BF9 0d 8f40800000 effffffa2c movl $1082130432,_sgl_value_2
810 00028C04 # /*
811 00028C04 # * If LOOP ON ERROR is set, this is the loop for this subtest.
812 00028C04 # * The force loop flag is set after the first error.
813 00028C04 # */
814 00028C04 # asm("_pipe4_6_lp1:");
815 00028C04 _pipe4_6_lp1:
816 00028C04 # asm("ldf _sgl_value_1"); /* load the operand */
817 00028C04 06 effffffa26 ldf _sgl_value_1
818 00028C0A # asm("nop");
819 00028C0A 10 nop
820 00028C0B # asm("stf _sgl_st_acc"); /* store the result */
821 00028C0B 26 effffffa1f stf _sgl_st_acc
822 00028C11 # asm("nop");
823 00028C11 10 nop
824 00028C12 # asm("ldf _sgl_value_2"); /* load a floating '1' */
825 00028C12 06 effffffa18 ldf _sgl_value_2
826 00028C18 # asm("nop");
827 00028C18 10 nop
828 00028C19 # asm("mulf _sgl_value_2"); /* multipy by a '1' */
829 00028C19 e6 effffffa11 mulf _sgl_value_2
830 00028C1F # asm("nop");
831 00028C1F 10 nop
832 00028C20 # asm("mulf _sgl_value_1"); /* multipy by the operand */
833 00028C20 e6 effffffa0a mulf _sgl_value_1
834 00028C26 # asm("nop");
835 00028C26 10 nop
836 00028C27 # asm("stf _sgl_value_6"); /* store the result */
837 00028C27 26 effffffa03 stf _sgl_value_6
838 00028C2D # if( force_loop );
839 00028C2D 5d effffff9fd tstl _force_loop
840 00028C33 31 00 jeql L306
841 00028C35 # asm("brb _pipe4_6_lp1");; /* loop on the error */
842 00028C35 L306:
843 00028C35 11 cd brb _pipe4_6_lp1
844 00028C37 # /*
845 00028C37 # * verify the results
846 00028C37 # */
847 00028C37 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
848 00028C37 # (sgl_value_6 != sgl_expected) )
849 00028C37 1d effffff9f3 effffff9ee cmpl _sgl_st_acc,_sgl_expected
850 00028C42 21 0d jneq L9994
851 00028C44 1d effffff9e6 effffff9e1 cmpl _sgl_value_6,_sgl_expected
852 00028C4F 31 42 jeql L307
853 00028C51 L9994:
854 00028C51 # {
855 00028C51 # errcnt++; /* bump the error count */
856 00028C51 6d effffff9d9 incl _errcnt
857 00028C57 # if ( prt_error )
858 00028C57 5d effffff9d3 tstl _prt_error
859 00028C5D 31 0d jeql L308
860 00028C5F # print_pipe4_er("Cache Data, 1 NO-OP");
861 00028C5F .data 1
862 00000de7 * L309:
863 00000de7 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
864 00000dfb * .text
865 00028C5F dd 8f00000de7 pushl $L309
866 00028C65 fe 08 ef000005a2 callf $8,_print_pipe4_er
867 00028C6C # if ( halt_flg )
868 00028C6C L308:
869 00028C6C 5d effffff9be tstl _halt_flg
870 00028C72 31 0d jeql L310
871 00028C74 # pipe4_er_hlt( subtest );
872 00028C74 dd effffff9b6 pushl _subtest
873 00028C7A fe 08 ef000006b3 callf $8,_pipe4_er_hlt
874 00028C81 # if ( loop_on_err ) {
875 00028C81 L310:
876 00028C81 5d effffff9a9 tstl _loop_on_err
877 00028C87 31 0a jeql L311
878 00028C89 # force_loop = TRUE; /* set the force loop flag */
879 00028C89 0d 01 effffff9a0 movl $1,_force_loop
880 00028C90 # asm("brw _pipe4_6_lp1"); /* and loop */
881 00028C90 13 ff71 brw _pipe4_6_lp1
882 00028C93 # }
883 00028C93 # } /* end of compare error */
884 00028C93 L311:
885 00028C93 # } while( index++ < max_ldf_1_index );
886 00028C93 L307:
887 00028C93 L304:
888 00028C93 0d effffff997 50 movl _index,r0
889 00028C9A 6d effffff990 incl _index
890 00028CA0 1d 50 effffff989 cmpl r0,_max_ldf_1_index
891 00028CA7 81 03 13 ff21 jlss L305
892 00028CAC L303:
893 00028CAC # } /* end of subtest 6 */
894 00028CAC 40 ret#2
895 00028CAD .set L299,0x0
896 00028CAD L301:
897 00028CAD 13 ff11 jbr L302
898 00028CB0 .data
899 00000d78 * .text
900 00028CB0 .align 1
901 00028CB0 .globl _pipe4_7
902 00028CB0 _pipe4_7:
903 00028CB0 0000 .word L312
904 00028CB2 #
905 00028CB2 #
906 00028CB2 #
907 00028CB2 #
908 00028CB2 #
909 00028CB2 #
910 00028CB2 # /************************************************************************
911 00028CB2 # *
912 00028CB2 # * SUBTEST 7
913 00028CB2 # * data in Cache, 2 NO-OPs
914 00028CB2 # *
915 00028CB2 # ************************************************************************/
916 00028CB2 # pipe4_7()
917 00028CB2 # {
918 00028CB2 13 00f1 jbr L314
919 00028CB5 L315:
920 00028CB5 # force_loop = FALSE; /* clear force_loop flag */
921 00028CB5 4d effffff975 clrl _force_loop
922 00028CBB # index = 0;
923 00028CBB 4d effffff96f clrl _index
924 00028CC1 # do
925 00028CC1 L318:
926 00028CC1 # {
927 00028CC1 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
928 00028CC1 0d effffff969 50 movl _index,r0
929 00028CC8 48 03 50 50 shll $3,r0,r0
930 00028CCC 0d e000000000 effffff959 movl _ldf_1_data(r0),_sgl_value_1
931 00028CD7 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
932 00028CD7 0d effffff953 50 movl _index,r0
933 00028CDE 48 03 50 50 shll $3,r0,r0
934 00028CE2 0d e000000004 effffff943 movl _ldf_1_data+4(r0),_sgl_expected
935 00028CED # sgl_value_2 = 0x40800000; /* floating '1' */
936 00028CED 0d 8f40800000 effffff938 movl $1082130432,_sgl_value_2
937 00028CF8 # /*
938 00028CF8 # * If LOOP ON ERROR is set, this is the loop for this subtest.
939 00028CF8 # * The force loop flag is set after the first error.
940 00028CF8 # */
941 00028CF8 # asm("_pipe4_7_lp1:");
942 00028CF8 _pipe4_7_lp1:
943 00028CF8 # asm("ldf _sgl_value_1"); /* load the operand */
944 00028CF8 06 effffff932 ldf _sgl_value_1
945 00028CFE # asm("nop");
946 00028CFE 10 nop
947 00028CFF # asm("nop");
948 00028CFF 10 nop
949 00028D00 # asm("stf _sgl_st_acc"); /* store the result */
950 00028D00 26 effffff92a stf _sgl_st_acc
951 00028D06 # asm("nop");
952 00028D06 10 nop
953 00028D07 # asm("nop");
954 00028D07 10 nop
955 00028D08 # asm("ldf _sgl_value_2"); /* load a floating '1' */
956 00028D08 06 effffff922 ldf _sgl_value_2
957 00028D0E # asm("nop");
958 00028D0E 10 nop
959 00028D0F # asm("nop");
960 00028D0F 10 nop
961 00028D10 # asm("mulf _sgl_value_2"); /* multipy by '1' */
962 00028D10 e6 effffff91a mulf _sgl_value_2
963 00028D16 # asm("nop");
964 00028D16 10 nop
965 00028D17 # asm("nop");
966 00028D17 10 nop
967 00028D18 # asm("mulf _sgl_value_1"); /* multipy by the operand */
968 00028D18 e6 effffff912 mulf _sgl_value_1
969 00028D1E # asm("nop");
970 00028D1E 10 nop
971 00028D1F # asm("nop");
972 00028D1F 10 nop
973 00028D20 # asm("stf _sgl_value_6"); /* store the result */
974 00028D20 26 effffff90a stf _sgl_value_6
975 00028D26 # if( force_loop );
976 00028D26 5d effffff904 tstl _force_loop
977 00028D2C 31 00 jeql L319
978 00028D2E # asm("brb _pipe4_7_lp1");; /* loop on the error */
979 00028D2E L319:
980 00028D2E 11 c8 brb _pipe4_7_lp1
981 00028D30 # /*
982 00028D30 # * verify the results
983 00028D30 # */
984 00028D30 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
985 00028D30 # (sgl_value_6 != sgl_expected) )
986 00028D30 1d effffff8fa effffff8f5 cmpl _sgl_st_acc,_sgl_expected
987 00028D3B 21 0d jneq L9993
988 00028D3D 1d effffff8ed effffff8e8 cmpl _sgl_value_6,_sgl_expected
989 00028D48 31 42 jeql L320
990 00028D4A L9993:
991 00028D4A # {
992 00028D4A # errcnt++; /* bump the error count */
993 00028D4A 6d effffff8e0 incl _errcnt
994 00028D50 # if ( prt_error )
995 00028D50 5d effffff8da tstl _prt_error
996 00028D56 31 0d jeql L321
997 00028D58 # print_pipe4_er("Cache Data, 2 NO-OPs");
998 00028D58 .data 1
999 00000dfb * L322:
1000 00000dfb * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
2204E4F2D4F507300
1001 00000e10 * .text
1002 00028D58 dd 8f00000dfb pushl $L322
1003 00028D5E fe 08 ef000004a9 callf $8,_print_pipe4_er
1004 00028D65 # if ( halt_flg )
1005 00028D65 L321:
1006 00028D65 5d effffff8c5 tstl _halt_flg
1007 00028D6B 31 0d jeql L323
1008 00028D6D # pipe4_er_hlt( subtest );
1009 00028D6D dd effffff8bd pushl _subtest
1010 00028D73 fe 08 ef000005ba callf $8,_pipe4_er_hlt
1011 00028D7A # if ( loop_on_err ) {
1012 00028D7A L323:
1013 00028D7A 5d effffff8b0 tstl _loop_on_err
1014 00028D80 31 0a jeql L324
1015 00028D82 # force_loop = TRUE; /* set the force loop flag */
1016 00028D82 0d 01 effffff8a7 movl $1,_force_loop
1017 00028D89 # asm("brw _pipe4_7_lp1"); /* and loop */
1018 00028D89 13 ff6c brw _pipe4_7_lp1
1019 00028D8C # }
1020 00028D8C # } /* end of compare error */
1021 00028D8C L324:
1022 00028D8C # } while( index++ < max_ldf_1_index );
1023 00028D8C L320:
1024 00028D8C L317:
1025 00028D8C 0d effffff89e 50 movl _index,r0
1026 00028D93 6d effffff897 incl _index
1027 00028D99 1d 50 effffff890 cmpl r0,_max_ldf_1_index
1028 00028DA0 81 03 13 ff1c jlss L318
1029 00028DA5 L316:
1030 00028DA5 # } /* end of subtest 7 */
1031 00028DA5 40 ret#2
1032 00028DA6 .set L312,0x0
1033 00028DA6 L314:
1034 00028DA6 13 ff0c jbr L315
1035 00028DA9 .data
1036 00000d78 * .text
1037 00028DA9 00 .align 1
1038 00028DAA .globl _pipe4_8
1039 00028DAA _pipe4_8:
1040 00028DAA 0000 .word L325
1041 00028DAC #
1042 00028DAC #
1043 00028DAC #
1044 00028DAC #
1045 00028DAC #
1046 00028DAC #
1047 00028DAC # /************************************************************************
1048 00028DAC # *
1049 00028DAC # * SUBTEST 8
1050 00028DAC # * data in Cache, 3 NO-OPs
1051 00028DAC # *
1052 00028DAC # ************************************************************************/
1053 00028DAC # pipe4_8()
1054 00028DAC # {
1055 00028DAC 13 00f6 jbr L327
1056 00028DAF L328:
1057 00028DAF # force_loop = FALSE; /* clear force_loop flag */
1058 00028DAF 4d effffff87b clrl _force_loop
1059 00028DB5 # index = 0;
1060 00028DB5 4d effffff875 clrl _index
1061 00028DBB # do
1062 00028DBB L331:
1063 00028DBB # {
1064 00028DBB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1065 00028DBB 0d effffff86f 50 movl _index,r0
1066 00028DC2 48 03 50 50 shll $3,r0,r0
1067 00028DC6 0d e000000000 effffff85f movl _ldf_1_data(r0),_sgl_value_1
1068 00028DD1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1069 00028DD1 0d effffff859 50 movl _index,r0
1070 00028DD8 48 03 50 50 shll $3,r0,r0
1071 00028DDC 0d e000000004 effffff849 movl _ldf_1_data+4(r0),_sgl_expected
1072 00028DE7 # sgl_value_2 = 0x40800000; /* floating '1' */
1073 00028DE7 0d 8f40800000 effffff83e movl $1082130432,_sgl_value_2
1074 00028DF2 # /*
1075 00028DF2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1076 00028DF2 # * The force loop flag is set after the first error.
1077 00028DF2 # */
1078 00028DF2 # asm("_pipe4_8_lp1:");
1079 00028DF2 _pipe4_8_lp1:
1080 00028DF2 # asm("ldf _sgl_value_1"); /* load the operand */
1081 00028DF2 06 effffff838 ldf _sgl_value_1
1082 00028DF8 # asm("nop");
1083 00028DF8 10 nop
1084 00028DF9 # asm("nop");
1085 00028DF9 10 nop
1086 00028DFA # asm("nop");
1087 00028DFA 10 nop
1088 00028DFB # asm("stf _sgl_st_acc"); /* store the result */
1089 00028DFB 26 effffff82f stf _sgl_st_acc
1090 00028E01 # asm("nop");
1091 00028E01 10 nop
1092 00028E02 # asm("nop");
1093 00028E02 10 nop
1094 00028E03 # asm("nop");
1095 00028E03 10 nop
1096 00028E04 # asm("ldf _sgl_value_2"); /* load a floating '1' */
1097 00028E04 06 effffff826 ldf _sgl_value_2
1098 00028E0A # asm("nop");
1099 00028E0A 10 nop
1100 00028E0B # asm("nop");
1101 00028E0B 10 nop
1102 00028E0C # asm("nop");
1103 00028E0C 10 nop
1104 00028E0D # asm("mulf _sgl_value_2"); /* multipy by a '1' */
1105 00028E0D e6 effffff81d mulf _sgl_value_2
1106 00028E13 # asm("nop");
1107 00028E13 10 nop
1108 00028E14 # asm("nop");
1109 00028E14 10 nop
1110 00028E15 # asm("nop");
1111 00028E15 10 nop
1112 00028E16 # asm("mulf _sgl_value_1"); /* multipy by the operand */
1113 00028E16 e6 effffff814 mulf _sgl_value_1
1114 00028E1C # asm("nop");
1115 00028E1C 10 nop
1116 00028E1D # asm("nop");
1117 00028E1D 10 nop
1118 00028E1E # asm("nop");
1119 00028E1E 10 nop
1120 00028E1F # asm("stf _sgl_value_6"); /* store the result */
1121 00028E1F 26 effffff80b stf _sgl_value_6
1122 00028E25 # if( force_loop );
1123 00028E25 5d effffff805 tstl _force_loop
1124 00028E2B 31 00 jeql L332
1125 00028E2D # asm("brb _pipe4_8_lp1");; /* loop on the error */
1126 00028E2D L332:
1127 00028E2D 11 c3 brb _pipe4_8_lp1
1128 00028E2F # /*
1129 00028E2F # * verify the results
1130 00028E2F # */
1131 00028E2F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1132 00028E2F # (sgl_value_6 != sgl_expected) )
1133 00028E2F 1d effffff7fb effffff7f6 cmpl _sgl_st_acc,_sgl_expected
1134 00028E3A 21 0d jneq L9992
1135 00028E3C 1d effffff7ee effffff7e9 cmpl _sgl_value_6,_sgl_expected
1136 00028E47 31 42 jeql L333
1137 00028E49 L9992:
1138 00028E49 # {
1139 00028E49 # errcnt++; /* bump the error count */
1140 00028E49 6d effffff7e1 incl _errcnt
1141 00028E4F # if ( prt_error )
1142 00028E4F 5d effffff7db tstl _prt_error
1143 00028E55 31 0d jeql L334
1144 00028E57 # print_pipe4_er("Cache Data, 3 NO-OPs");
1145 00028E57 .data 1
1146 00000e10 * L335:
1147 00000e10 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
3204E4F2D4F507300
1148 00000e25 * .text
1149 00028E57 dd 8f00000e10 pushl $L335
1150 00028E5D fe 08 ef000003aa callf $8,_print_pipe4_er
1151 00028E64 # if ( halt_flg )
1152 00028E64 L334:
1153 00028E64 5d effffff7c6 tstl _halt_flg
1154 00028E6A 31 0d jeql L336
1155 00028E6C # pipe4_er_hlt( subtest );
1156 00028E6C dd effffff7be pushl _subtest
1157 00028E72 fe 08 ef000004bb callf $8,_pipe4_er_hlt
1158 00028E79 # if ( loop_on_err ) {
1159 00028E79 L336:
1160 00028E79 5d effffff7b1 tstl _loop_on_err
1161 00028E7F 31 0a jeql L337
1162 00028E81 # force_loop = TRUE; /* set the force loop flag */
1163 00028E81 0d 01 effffff7a8 movl $1,_force_loop
1164 00028E88 # asm("brw _pipe4_8_lp1"); /* and loop */
1165 00028E88 13 ff67 brw _pipe4_8_lp1
1166 00028E8B # }
1167 00028E8B # } /* end of compare error */
1168 00028E8B L337:
1169 00028E8B # } while( index++ < max_ldf_1_index );
1170 00028E8B L333:
1171 00028E8B L330:
1172 00028E8B 0d effffff79f 50 movl _index,r0
1173 00028E92 6d effffff798 incl _index
1174 00028E98 1d 50 effffff791 cmpl r0,_max_ldf_1_index
1175 00028E9F 81 03 13 ff17 jlss L331
1176 00028EA4 L329:
1177 00028EA4 # } /* end of subtest 8 */
1178 00028EA4 40 ret#2
1179 00028EA5 .set L325,0x0
1180 00028EA5 L327:
1181 00028EA5 13 ff07 jbr L328
1182 00028EA8 .data
1183 00000d78 * .text
1184 00028EA8 .align 1
1185 00028EA8 .globl _pipe4_9
1186 00028EA8 _pipe4_9:
1187 00028EA8 0000 .word L338
1188 00028EAA #
1189 00028EAA #
1190 00028EAA #
1191 00028EAA #
1192 00028EAA #
1193 00028EAA #
1194 00028EAA # /*****************************************************************************
1195 00028EAA # *
1196 00028EAA # * SUBTEST 9
1197 00028EAA # * data on the stack, no NO-OPs
1198 00028EAA # *
1199 00028EAA # *****************************************************************************/
1200 00028EAA # pipe4_9()
1201 00028EAA # {
1202 00028EAA 13 018d jbr L340
1203 00028EAD L341:
1204 00028EAD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1205 00028EAD ed 6d effffff77c moval (r13),_pre_event_fp
1206 00028EB4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1207 00028EB4 ed 6e effffff775 moval (r14),_pre_event_sp
1208 00028EBB # force_loop = FALSE; /* clear force_loop flag */
1209 00028EBB 4d effffff76f clrl _force_loop
1210 00028EC1 # index = 0;
1211 00028EC1 4d effffff769 clrl _index
1212 00028EC7 # do
1213 00028EC7 L344:
1214 00028EC7 # {
1215 00028EC7 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1216 00028EC7 0d effffff763 50 movl _index,r0
1217 00028ECE 48 03 50 50 shll $3,r0,r0
1218 00028ED2 0d e000000000 effffff753 movl _ldf_1_data(r0),_sgl_value_1
1219 00028EDD # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1220 00028EDD 0d effffff74d 50 movl _index,r0
1221 00028EE4 48 03 50 50 shll $3,r0,r0
1222 00028EE8 0d e000000004 effffff73d movl _ldf_1_data+4(r0),_sgl_expected
1223 00028EF3 # sgl_value_2 = 0x40800000; /* floating '1' */
1224 00028EF3 0d 8f40800000 effffff732 movl $1082130432,_sgl_value_2
1225 00028EFE # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1226 00028EFE ed effffff72c effffff727 moval _pointer_data,_sgl_value_4
1227 00028F09 # /*
1228 00028F09 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1229 00028F09 # * The force loop flag is set after the first error.
1230 00028F09 # */
1231 00028F09 # asm("_pipe4_9_lp1:");
1232 00028F09 _pipe4_9_lp1:
1233 00028F09 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1234 00028F09 ed effffff721 5e moval _pointer_data,r14
1235 00028F10 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1236 00028F10 0d effffff71a 7e movl _sgl_value_1,-(r14)
1237 00028F17 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '1' */
1238 00028F17 0d effffff713 7e movl _sgl_value_2,-(r14)
1239 00028F1E # asm("movl _sgl_value_2,-(r14)"); /* push a '1' again */
1240 00028F1E 0d effffff70c 7e movl _sgl_value_2,-(r14)
1241 00028F25 # asm("movl _sgl_value_1,-(r14)"); /* push the operand again */
1242 00028F25 0d effffff705 7e movl _sgl_value_1,-(r14)
1243 00028F2C # /*
1244 00028F2C # * now pop the data off the stack
1245 00028F2C # */
1246 00028F2C #
1247 00028F2C # asm("ldf (r14)+"); /* load the operand */
1248 00028F2C 06 8e ldf (r14)+
1249 00028F2E # asm("stf r5"); /* store the result */
1250 00028F2E 26 55 stf r5
1251 00028F30 # asm("ldf (r14)+"); /* load a floating '1' */
1252 00028F30 06 8e ldf (r14)+
1253 00028F32 # asm("mulf (r14)+"); /* multipy by a '1' */
1254 00028F32 e6 8e mulf (r14)+
1255 00028F34 # asm("mulf (r14)+"); /* multipy by the operand */
1256 00028F34 e6 8e mulf (r14)+
1257 00028F36 # asm("stf r6"); /* store the result */
1258 00028F36 26 56 stf r6
1259 00028F38 # if( force_loop );
1260 00028F38 5d effffff6f2 tstl _force_loop
1261 00028F3E 31 00 jeql L345
1262 00028F40 # asm("brb _pipe4_9_lp1");; /* loop on the error */
1263 00028F40 L345:
1264 00028F40 11 c7 brb _pipe4_9_lp1
1265 00028F42 # /*
1266 00028F42 # * verify the results
1267 00028F42 # */
1268 00028F42 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1269 00028F42 0d 55 effffff6e7 movl r5,_sgl_st_acc
1270 00028F49 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1271 00028F49 0d 56 effffff6e0 movl r6,_sgl_value_6
1272 00028F50 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1273 00028F50 ed 6e effffff6d9 moval (r14),_sgl_value_5
1274 00028F57 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1275 00028F57 # (sgl_value_6 != sgl_expected) ||
1276 00028F57 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1277 00028F57 1d effffff6d3 effffff6ce cmpl _sgl_st_acc,_sgl_expected
1278 00028F62 21 1d jneq L9991
1279 00028F64 1d effffff6c6 effffff6c1 cmpl _sgl_value_6,_sgl_expected
1280 00028F6F 21 10 jneq L9991
1281 00028F71 1d effffff6b9 effffff6b4 cmpl _sgl_value_5,_sgl_value_4
1282 00028F7C 21 03 13 0091 jeql L346
1283 00028F81 L9991:
1284 00028F81 # {
1285 00028F81 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1286 00028F81 0d effffff6a9 5d movl _pre_event_fp,r13
1287 00028F88 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1288 00028F88 0d effffff6a2 5e movl _pre_event_sp,r14
1289 00028F8F # errcnt++; /* bump the error count */
1290 00028F8F 6d effffff69b incl _errcnt
1291 00028F95 # if ( prt_error ) {
1292 00028F95 5d effffff695 tstl _prt_error
1293 00028F9B 31 4e jeql L347
1294 00028F9D # print_pipe4_er("POP data from the STACK");
1295 00028F9D .data 1
1296 00000e25 * L348:
1297 00000e25 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
D2074686520535441434B00
1298 00000e3d * .text
1299 00028F9D dd 8f00000e25 pushl $L348
1300 00028FA3 fe 08 ef00000264 callf $8,_print_pipe4_er
1301 00028FAA # writes("final Stack Pointer = ");
1302 00028FAA .data 1
1303 00000e3d * L349:
1304 00000e3d * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1305 00000e54 * .text
1306 00028FAA dd 8f00000e3d pushl $L349
1307 00028FB0 fe 08 effffff679 callf $8,_writes
1308 00028FB7 # write32h( sgl_value_5 );
1309 00028FB7 dd effffff673 pushl _sgl_value_5
1310 00028FBD fe 08 effffff66c callf $8,_write32h
1311 00028FC4 # writes(", expected SP = ");
1312 00028FC4 .data 1
1313 00000e54 * L351:
1314 00000e54 * 2C20206578706563746564205 .ascii ", expected SP = \0"
350203D2000
1315 00000e66 * .text
1316 00028FC4 dd 8f00000e54 pushl $L351
1317 00028FCA fe 08 effffff65f callf $8,_writes
1318 00028FD1 # write32h( sgl_value_4 );
1319 00028FD1 dd effffff659 pushl _sgl_value_4
1320 00028FD7 fe 08 effffff652 callf $8,_write32h
1321 00028FDE # writes("\n");
1322 00028FDE .data 1
1323 00000e66 * L352:
1324 00000e66 * 0A00 .ascii "\12\0"
1325 00000e68 * .text
1326 00028FDE dd 8f00000e66 pushl $L352
1327 00028FE4 fe 08 effffff645 callf $8,_writes
1328 00028FEB # }
1329 00028FEB # if ( halt_flg )
1330 00028FEB L347:
1331 00028FEB 5d effffff63f tstl _halt_flg
1332 00028FF1 31 0d jeql L353
1333 00028FF3 # pipe4_er_hlt( subtest );
1334 00028FF3 dd effffff637 pushl _subtest
1335 00028FF9 fe 08 ef00000334 callf $8,_pipe4_er_hlt
1336 00029000 # if ( loop_on_err ) {
1337 00029000 L353:
1338 00029000 5d effffff62a tstl _loop_on_err
1339 00029006 31 0a jeql L354
1340 00029008 # force_loop = TRUE; /* set the force loop flag */
1341 00029008 0d 01 effffff621 movl $1,_force_loop
1342 0002900F # asm("brw _pipe4_9_lp1"); /* and loop */
1343 0002900F 13 fef7 brw _pipe4_9_lp1
1344 00029012 # }
1345 00029012 # } /* end of compare error */
1346 00029012 L354:
1347 00029012 # } while( index++ < max_ldf_1_index );
1348 00029012 L346:
1349 00029012 L343:
1350 00029012 0d effffff618 50 movl _index,r0
1351 00029019 6d effffff611 incl _index
1352 0002901F 1d 50 effffff60a cmpl r0,_max_ldf_1_index
1353 00029026 81 03 13 fe9c jlss L344
1354 0002902B L342:
1355 0002902B # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1356 0002902B 0d effffff5ff 5d movl _pre_event_fp,r13
1357 00029032 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1358 00029032 0d effffff5f8 5e movl _pre_event_sp,r14
1359 00029039 # } /* end of subtest 9 */
1360 00029039 40 ret#2
1361 0002903A .set L338,0x0
1362 0002903A L340:
1363 0002903A 13 fe70 jbr L341
1364 0002903D .data
1365 00000d78 * .text
1366 0002903D 00 .align 1
1367 0002903E .globl _pipe4_10
1368 0002903E _pipe4_10:
1369 0002903E 0000 .word L355
1370 00029040 #
1371 00029040 #
1372 00029040 #
1373 00029040 #
1374 00029040 #
1375 00029040 #
1376 00029040 # /******************************************************************************
1377 00029040 # *
1378 00029040 # * SUBTEST 10
1379 00029040 # * get data via indexed FRAME pointer
1380 00029040 # *
1381 00029040 # * ADDR INDEX DATA
1382 00029040 # * pointer_data 4 <the 1st STF result goes here>
1383 00029040 # * pointer_data-4 3 <the 2nd STF result goes here>
1384 00029040 # * pointer_data-8 2 <operand data>
1385 00029040 # * pointer_data-12 1 <floating '1'>
1386 00029040 # * pointer_data-16 0 point the frame pointer here
1387 00029040 # *
1388 00029040 # ******************************************************************************/
1389 00029040 # pipe4_10()
1390 00029040 # {
1391 00029040 13 01c8 jbr L357
1392 00029043 L358:
1393 00029043 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1394 00029043 ed 6d effffff5e6 moval (r13),_pre_event_fp
1395 0002904A # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1396 0002904A ed 6e effffff5df moval (r14),_pre_event_sp
1397 00029051 # force_loop = FALSE; /* clear force_loop flag */
1398 00029051 4d effffff5d9 clrl _force_loop
1399 00029057 # index = 0;
1400 00029057 4d effffff5d3 clrl _index
1401 0002905D # do
1402 0002905D L361:
1403 0002905D # {
1404 0002905D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1405 0002905D 0d effffff5cd 50 movl _index,r0
1406 00029064 48 03 50 50 shll $3,r0,r0
1407 00029068 0d e000000000 effffff5bd movl _ldf_1_data(r0),_sgl_value_1
1408 00029073 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1409 00029073 0d effffff5b7 50 movl _index,r0
1410 0002907A 48 03 50 50 shll $3,r0,r0
1411 0002907E 0d e000000004 effffff5a7 movl _ldf_1_data+4(r0),_sgl_expected
1412 00029089 # sgl_value_2 = 0x40800000; /* floating '1' */
1413 00029089 0d 8f40800000 effffff59c movl $1082130432,_sgl_value_2
1414 00029094 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1415 00029094 ed effffff596 effffff591 moval _pointer_data,_sgl_value_4
1416 0002909F # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1417 0002909F 2c 08 effffff58a subl2 $8,_sgl_value_4
1418 000290A6 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1419 000290A6 0d effffff584 fffffff57f movl _sgl_value_1,*_sgl_value_4
1420 000290B1 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1421 000290B1 2c 04 effffff578 subl2 $4,_sgl_value_4
1422 000290B8 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '1' */
1423 000290B8 0d effffff572 fffffff56d movl _sgl_value_2,*_sgl_value_4
1424 000290C3 # sgl_value_4 -= 4; /* get FRAME PTR address */
1425 000290C3 2c 04 effffff566 subl2 $4,_sgl_value_4
1426 000290CA # /*
1427 000290CA # * If LOOP ON ERROR is set, this is the loop for this subtest.
1428 000290CA # * The force loop flag is set after the first error.
1429 000290CA # */
1430 000290CA # asm("_pipe4_10_lp1:");
1431 000290CA _pipe4_10_lp1:
1432 000290CA # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1433 000290CA 0d effffff560 5d movl _sgl_value_4,r13
1434 000290D1 # asm("movl $1,r1"); /* r1 index = 1 longwords */
1435 000290D1 0d 01 51 movl $1,r1
1436 000290D4 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1437 000290D4 0d 02 52 movl $2,r2
1438 000290D7 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1439 000290D7 0d 03 53 movl $3,r3
1440 000290DA # asm("movl $4,r4"); /* r4 index = 4 longwords */
1441 000290DA 0d 04 54 movl $4,r4
1442 000290DD # asm("ldf (r13)[r2]"); /* load the op (indx = 2) */
1443 000290DD 06 426d ldf (r13)[r2]
1444 000290E0 # asm("stf (r13)[r4]"); /* store -index = 4 */
1445 000290E0 26 446d stf (r13)[r4]
1446 000290E3 # asm("ldf (r13)[r1]"); /* load '1' (indx = 1) */
1447 000290E3 06 416d ldf (r13)[r1]
1448 000290E6 # asm("mulf (r13)[r1]"); /* multiply by a '1' */
1449 000290E6 e6 416d mulf (r13)[r1]
1450 000290E9 # asm("mulf (r13)[r2]"); /* multiply by the operand */
1451 000290E9 e6 426d mulf (r13)[r2]
1452 000290EC # asm("stf (r13)[r3]"); /* store -index = 3 */
1453 000290EC 26 436d stf (r13)[r3]
1454 000290EF # if( force_loop );
1455 000290EF 5d effffff53b tstl _force_loop
1456 000290F5 31 00 jeql L362
1457 000290F7 # asm("brb _pipe4_10_lp1");; /* loop on the error */
1458 000290F7 L362:
1459 000290F7 11 d1 brb _pipe4_10_lp1
1460 000290F9 # /*
1461 000290F9 # * verify the results
1462 000290F9 # */
1463 000290F9 # sgl_st_acc = pointer_data; /* save 1st stored value */
1464 000290F9 0d effffff531 effffff52c movl _pointer_data,_sgl_st_acc
1465 00029104 # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1466 00029104 ed effffff526 effffff521 moval _pointer_data,_sgl_value_5
1467 0002910F # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1468 0002910F 2c 04 effffff51a subl2 $4,_sgl_value_5
1469 00029116 # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1470 00029116 0d fffffff514 effffff50f movl *_sgl_value_5,_sgl_value_6
1471 00029121 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1472 00029121 ed 6d effffff508 moval (r13),_sgl_value_5
1473 00029128 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1474 00029128 # (sgl_value_6 != sgl_expected) ||
1475 00029128 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1476 00029128 1d effffff502 effffff4fd cmpl _sgl_st_acc,_sgl_expected
1477 00029133 21 1d jneq L9990
1478 00029135 1d effffff4f5 effffff4f0 cmpl _sgl_value_6,_sgl_expected
1479 00029140 21 10 jneq L9990
1480 00029142 1d effffff4e8 effffff4e3 cmpl _sgl_value_5,_sgl_value_4
1481 0002914D 21 03 13 0091 jeql L363
1482 00029152 L9990:
1483 00029152 # {
1484 00029152 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1485 00029152 0d effffff4d8 5d movl _pre_event_fp,r13
1486 00029159 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1487 00029159 0d effffff4d1 5e movl _pre_event_sp,r14
1488 00029160 # errcnt++; /* bump the error count */
1489 00029160 6d effffff4ca incl _errcnt
1490 00029166 # if ( prt_error ) {
1491 00029166 5d effffff4c4 tstl _prt_error
1492 0002916C 31 4e jeql L364
1493 0002916E # print_pipe4_er("indexed FP addressing");
1494 0002916E .data 1
1495 00000e68 * L365:
1496 00000e68 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1497 00000e7e * .text
1498 0002916E dd 8f00000e68 pushl $L365
1499 00029174 fe 08 ef00000093 callf $8,_print_pipe4_er
1500 0002917B # writes("final Frame Pointer = ");
1501 0002917B .data 1
1502 00000e7e * L366:
1503 00000e7e * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1504 00000e95 * .text
1505 0002917B dd 8f00000e7e pushl $L366
1506 00029181 fe 08 effffff4a8 callf $8,_writes
1507 00029188 # writeh( sgl_value_5 );
1508 00029188 dd effffff4a2 pushl _sgl_value_5
1509 0002918E fe 08 effffff49b callf $8,_writeh
1510 00029195 # writes(", expected FP = ");
1511 00029195 .data 1
1512 00000e95 * L368:
1513 00000e95 * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1514 00000ea7 * .text
1515 00029195 dd 8f00000e95 pushl $L368
1516 0002919B fe 08 effffff48e callf $8,_writes
1517 000291A2 # writeh( sgl_value_4 );
1518 000291A2 dd effffff488 pushl _sgl_value_4
1519 000291A8 fe 08 effffff481 callf $8,_writeh
1520 000291AF # writes("\n");
1521 000291AF .data 1
1522 00000ea7 * L369:
1523 00000ea7 * 0A00 .ascii "\12\0"
1524 00000ea9 * .text
1525 000291AF dd 8f00000ea7 pushl $L369
1526 000291B5 fe 08 effffff474 callf $8,_writes
1527 000291BC # }
1528 000291BC # if ( halt_flg )
1529 000291BC L364:
1530 000291BC 5d effffff46e tstl _halt_flg
1531 000291C2 31 0d jeql L370
1532 000291C4 # pipe4_er_hlt( subtest );
1533 000291C4 dd effffff466 pushl _subtest
1534 000291CA fe 08 ef00000163 callf $8,_pipe4_er_hlt
1535 000291D1 # if ( loop_on_err ) {
1536 000291D1 L370:
1537 000291D1 5d effffff459 tstl _loop_on_err
1538 000291D7 31 0a jeql L371
1539 000291D9 # force_loop = TRUE; /* set the force loop flag */
1540 000291D9 0d 01 effffff450 movl $1,_force_loop
1541 000291E0 # asm("brw _pipe4_10_lp1"); /* and loop */
1542 000291E0 13 fee7 brw _pipe4_10_lp1
1543 000291E3 # }
1544 000291E3 # } /* end of compare error */
1545 000291E3 L371:
1546 000291E3 # } while( index++ < max_ldf_1_index );
1547 000291E3 L363:
1548 000291E3 L360:
1549 000291E3 0d effffff447 50 movl _index,r0
1550 000291EA 6d effffff440 incl _index
1551 000291F0 1d 50 effffff439 cmpl r0,_max_ldf_1_index
1552 000291F7 81 03 13 fe61 jlss L361
1553 000291FC L359:
1554 000291FC # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1555 000291FC 0d effffff42e 5d movl _pre_event_fp,r13
1556 00029203 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1557 00029203 0d effffff427 5e movl _pre_event_sp,r14
1558 0002920A # } /* end of subtest 10 */
1559 0002920A 40 ret#2
1560 0002920B .set L355,0x0
1561 0002920B L357:
1562 0002920B 13 fe35 jbr L358
1563 0002920E .data
1564 00000d78 * .text
1565 0002920E .align 1
1566 0002920E .globl _print_pipe4_er
1567 0002920E _print_pipe4_er:
1568 0002920E 0000 .word L372
1569 00029210 #
1570 00029210 #
1571 00029210 # /******************************************************************************
1572 00029210 # *
1573 00029210 # *
1574 00029210 # * print an error in the following form
1575 00029210 # *
1576 00029210 # * operand = xxxxxxxx, 1st store = xxxxxxxx, data index = dd
1577 00029210 # * 2nd store = xxxxxxxx, expected Acc = xxxxxxxx
1578 00029210 # *
1579 00029210 # ******************************************************************************/
1580 00029210 # print_pipe4_er(msg)
1581 00029210 # char *msg;
1582 00029210 # {
1583 00029210 13 011d jbr L374
1584 00029213 L375:
1585 00029213 # writes("\n"); /* start a new print line */
1586 00029213 .data 1
1587 00000ea9 * L376:
1588 00000ea9 * 0A00 .ascii "\12\0"
1589 00000eab * .text
1590 00029213 dd 8f00000ea9 pushl $L376
1591 00029219 fe 08 effffff410 callf $8,_writes
1592 00029220 # writes("cycle: ");
1593 00029220 .data 1
1594 00000eab * L377:
1595 00000eab * 6379636C653A2000 .ascii "cycle: \0"
1596 00000eb3 * .text
1597 00029220 dd 8f00000eab pushl $L377
1598 00029226 fe 08 effffff403 callf $8,_writes
1599 0002922D # writed( cycle );
1600 0002922D dd effffff3fd pushl _cycle
1601 00029233 fe 08 effffff3f6 callf $8,_writed
1602 0002923A # writes(" test ");
1603 0002923A .data 1
1604 00000eb3 * L379:
1605 00000eb3 * 20746573742000 .ascii " test \0"
1606 00000eba * .text
1607 0002923A dd 8f00000eb3 pushl $L379
1608 00029240 fe 08 effffff3e9 callf $8,_writes
1609 00029247 # writed( test_no );
1610 00029247 dd effffff3e3 pushl _test_no
1611 0002924D fe 08 effffff3dc callf $8,_writed
1612 00029254 # writes(" (Pipe 4), subtest ");
1613 00029254 .data 1
1614 00000eba * L380:
1615 00000eba * 202028506970652034292C207 .ascii " (Pipe 4), subtest \0"
37562746573742000
1616 00000ecf * .text
1617 00029254 dd 8f00000eba pushl $L380
1618 0002925A fe 08 effffff3cf callf $8,_writes
1619 00029261 # writed( subtest );
1620 00029261 dd effffff3c9 pushl _subtest
1621 00029267 fe 08 effffff3c2 callf $8,_writed
1622 0002926E # writes(" error - ");
1623 0002926E .data 1
1624 00000ecf * L381:
1625 00000ecf * 206572726F72202D2000 .ascii " error - \0"
1626 00000ed9 * .text
1627 0002926E dd 8f00000ecf pushl $L381
1628 00029274 fe 08 effffff3b5 callf $8,_writes
1629 0002927B # writes( msg );
1630 0002927B dd ad04 pushl 4(fp)
1631 0002927E fe 08 effffff3ab callf $8,_writes
1632 00029285 # writec('\n');
1633 00029285 dd 0a pushl $10
1634 00029287 fe 08 effffff3a2 callf $8,_writec
1635 0002928E # writes(" LDF(op), STF, LDF(1.0), MULF(op), STF\n");
1636 0002928E .data 1
1637 00000ed9 * L383:
1638 00000ed9 * 204C4446286F70292C2053544 .ascii " LDF(op), STF, LDF(1.0), MULF(op), STF\12\0"
62C204C444628312E30292C20
4D554C46286F70292C2053544
60A00
1639 00000f01 * .text
1640 0002928E dd 8f00000ed9 pushl $L383
1641 00029294 fe 08 effffff395 callf $8,_writes
1642 0002929B # writes(" operand = ");
1643 0002929B .data 1
1644 00000f01 * L384:
1645 00000f01 * 20206F706572616E64203D200 .ascii " operand = \0"
0
1646 00000f0e * .text
1647 0002929B dd 8f00000f01 pushl $L384
1648 000292A1 fe 08 effffff388 callf $8,_writes
1649 000292A8 # write32h( sgl_value_1 );
1650 000292A8 dd effffff382 pushl _sgl_value_1
1651 000292AE fe 08 effffff37b callf $8,_write32h
1652 000292B5 # writes(", 1st store = ");
1653 000292B5 .data 1
1654 00000f0e * L385:
1655 00000f0e * 2C20202020203173742073746 .ascii ", 1st store = \0"
F7265203D2000
1656 00000f21 * .text
1657 000292B5 dd 8f00000f0e pushl $L385
1658 000292BB fe 08 effffff36e callf $8,_writes
1659 000292C2 # write32h( sgl_st_acc );
1660 000292C2 dd effffff368 pushl _sgl_st_acc
1661 000292C8 fe 08 effffff361 callf $8,_write32h
1662 000292CF # writes(", data index = ");
1663 000292CF .data 1
1664 00000f21 * L386:
1665 00000f21 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1666 00000f33 * .text
1667 000292CF dd 8f00000f21 pushl $L386
1668 000292D5 fe 08 effffff354 callf $8,_writes
1669 000292DC # writed( index );
1670 000292DC dd effffff34e pushl _index
1671 000292E2 fe 08 effffff347 callf $8,_writed
1672 000292E9 # writec('\n');
1673 000292E9 dd 0a pushl $10
1674 000292EB fe 08 effffff33e callf $8,_writec
1675 000292F2 # writes("2nd store = ");
1676 000292F2 .data 1
1677 00000f33 * L387:
1678 00000f33 * .ascii ""
1679 00000f33 * 326E642073746F7265203D200 .ascii "2nd store = \0"
0
1680 00000f40 * .text
1681 000292F2 dd 8f00000f33 pushl $L387
1682 000292F8 fe 08 effffff331 callf $8,_writes
1683 000292FF # write32h( sgl_value_6 );
1684 000292FF dd effffff32b pushl _sgl_value_6
1685 00029305 fe 08 effffff324 callf $8,_write32h
1686 0002930C # writes(", expected Acc = ");
1687 0002930C .data 1
1688 00000f40 * L388:
1689 00000f40 * 2C20206578706563746564204 .ascii ", expected Acc = \0"
16363203D2000
1690 00000f53 * .text
1691 0002930C dd 8f00000f40 pushl $L388
1692 00029312 fe 08 effffff317 callf $8,_writes
1693 00029319 # write32h( sgl_expected );
1694 00029319 dd effffff311 pushl _sgl_expected
1695 0002931F fe 08 effffff30a callf $8,_write32h
1696 00029326 # writec('\n');
1697 00029326 dd 0a pushl $10
1698 00029328 fe 08 effffff301 callf $8,_writec
1699 0002932F # }
1700 0002932F 40 ret#2
1701 00029330 .set L372,0x0
1702 00029330 L374:
1703 00029330 13 fee0 jbr L375
1704 00029333 .data
1705 00000d78 * .text
1706 00029333 00 .align 1
1707 00029334 .globl _pipe4_er_hlt
1708 00029334 _pipe4_er_hlt:
1709 00029334 0000 .word L389
1710 00029336 #
1711 00029336 #
1712 00029336 #
1713 00029336 #
1714 00029336 #
1715 00029336 # /******************************************************************************
1716 00029336 # *
1717 00029336 # * HALT ON ERROR ROUTINE
1718 00029336 # *
1719 00029336 # * halt with the necessary information saved in the registers
1720 00029336 # *
1721 00029336 # ******************************************************************************/
1722 00029336 # pipe4_er_hlt( subtest )
1723 00029336 # int subtest;
1724 00029336 # {
1725 00029336 11 6e jbr L391
1726 00029338 L392:
1727 00029338 # asm("movl _test_no,r0"); /* r0 = test number */
1728 00029338 0d effffff2f2 50 movl _test_no,r0
1729 0002933F # asm("movl _subtest,r1"); /* r1 = subtest number */
1730 0002933F 0d effffff2eb 51 movl _subtest,r1
1731 00029346 # asm("movl $1,r2"); /* r2 = error code */
1732 00029346 0d 01 52 movl $1,r2
1733 00029349 # asm("movl _cycle,r3"); /* r3 = cycle count */
1734 00029349 0d effffff2e1 53 movl _cycle,r3
1735 00029350 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1736 00029350 0d effffff2da 54 movl _sgl_value_1,r4
1737 00029357 # asm("movl _sgl_st_acc,r5"); /* r5 = 1st word stored */
1738 00029357 0d effffff2d3 55 movl _sgl_st_acc,r5
1739 0002935E # asm("movl _sgl_value_6,r6"); /* r6 = 2nd word stored */
1740 0002935E 0d effffff2cc 56 movl _sgl_value_6,r6
1741 00029365 # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
1742 00029365 0d effffff2c5 57 movl _sgl_expected,r7
1743 0002936C # asm("movl _index,r8"); /* r8 = data index */
1744 0002936C 0d effffff2be 58 movl _index,r8
1745 00029373 # asm("movl _sgl_value_2,r9"); /* r9 = floating one */
1746 00029373 0d effffff2b7 59 movl _sgl_value_2,r9
1747 0002937A # if( subtest == 9 ) {
1748 0002937A 1d ad04 09 cmpl 4(fp),$9
1749 0002937E 21 10 jneq L393
1750 00029380 # asm("movl _sgl_value_5,r10"); /* r10= final SP value */
1751 00029380 0d effffff2aa 5a movl _sgl_value_5,r10
1752 00029387 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */
1753 00029387 0d effffff2a3 5b movl _sgl_value_4,r11
1754 0002938E # } else
1755 0002938E 11 14 jbr L394
1756 00029390 L393:
1757 00029390 # if( subtest == 10 ) {
1758 00029390 1d ad04 0a cmpl 4(fp),$10
1759 00029394 21 0e jneq L395
1760 00029396 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */
1761 00029396 0d effffff294 5a movl _sgl_value_5,r10
1762 0002939D # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */
1763 0002939D 0d effffff28d 5b movl _sgl_value_4,r11
1764 000293A4 # };
1765 000293A4 L395:
1766 000293A4 L394:
1767 000293A4 # asm(".globl _pipe4_1_hlt");
1768 000293A4 .globl _pipe4_1_hlt
1769 000293A4 # asm("_pipe4_1_hlt:"); /* PC after the halt */
1770 000293A4 _pipe4_1_hlt:
1771 000293A4 # asm("halt"); /* HALT ... */
1772 000293A4 00 halt
1773 000293A5 # } /* end of halt on error */
1774 000293A5 40 ret#2
1775 000293A6 .set L389,0x0
1776 000293A6 L391:
1777 000293A6 11 90 jbr L392
1778 00000d78 * .data
1778 00000d78 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.